Zentrale "Drehscheibe" für verschiedene APIs

[OnDemand]

Hallo zusammen,

folgendes "Problem" Ich habe im Frontend eine Übersicht an Daten X (Ähnlich eines Kategoriebaumes im Onlineshop) Wenn man auf eine dieser Kategorien klickt, sollten Daten aus einer Quelle geholt werden. Die Quelle unterscheidet sich je nach User.

Nun muss nachdem ein User geklickt hat je nach Quelle ein anderer Apiaufruf gemacht werden. Jetzt hab ich folgenden Dummycode, mit dem bin ich aber alles andere als zufrieden! Ich schätze hier wären Interfaces angebracht, finde aber überhaupt keinen sinnvollen Einstieg.

Die anderen Marktplätze im switch würden eben wieder andere Formate bekommen, im Frontend will ich aber ein einheitliches Format haben um die Daten anzeigen zu können.

Kann mir jemand einen Denkanstoß geben?

public class ExportCategoryHandler {
    MarktplatzXYCategoriesApi marktplatzXYCategoriesApi = SpringContext.getBean(MarktplatzXYCategoriesApi.class);

    private List<ProductCategory> getCategories(Marketplace marketplace, MarketplaceSettings marketplaceSettings) {
        switch (marketplace.getMarketplaceName()) {
            case "XY":
                return transformXYCategoryToProductCategory(xyCategoriesApi.getCategories(marketplaceSettings));
        
        //hier müssten alle weiteren Marktplätze rein
        }
        return null;
    }

    private List<ProductCategory> transformXYCategoryToProductCategory(XYCategoriesResponse xyCategoriesResponse) {
        ArrayList<ProductCategory> productCategoryList = new ArrayList<>();
        for (XYCategoriesResponseItem xyCategoriesResponseItem : xyCategoriesResponse.getXYCategoriesResponse()) {
//Marktplatzformat in unser eigenes "Format" umwandeln
            ProductCategory productCategory = new ProductCategory(xyCategoriesResponseItem.getId(), xyCategoriesResponseItem.getParentId(), xyCategoriesResponseItem.getName());
            productCategoryList.add(productCategory);
        }
        return productCategoryList;
    }

 

[Barista]

Die Quelle unterscheidet sich je nach User.

In diesem Falle kannst Du anhand des Users die Quelle auswählen.

 

[OnDemand]

Ja genau, an die Quelle komm ich ran. Mir gehts eher um die Implemtierung für "welche API soll ich jetzt ansteuern". Macht das mit dem Switch da Sinn? Ich find irgendwie nich

 

[Barista]

Ja genau, an die Quelle komm ich ran. Mir gehts eher um die Implemtierung für "welche API soll ich jetzt ansteuern". Macht das mit dem Switch da Sinn? Ich find irgendwie nich

In OOP ist die typische Alternative Polymorphie.

Dann müssten die API-Objekte aus einer Factory kommen.

In der Factory wäre wiederum der switch oder eine Map mit API-Objekten bzw.API-Create-Objekten.

Damit wäre zumindest gesichert, dass alle switch-case-Zweige implementiert sind.

 

[OnDemand]

Ah ja Factory klingt gut. Bin ich mit folgendem Denken auf dem richtigen Weg?

1. ApiFactory

ApiFactory {
    ApiCategoryEndpoint getapiCategoryEndpoint(Marketplace marketplace){

        if(marketplace.equals("LIDL") {
            return new LidlCategoryEndpoint();
        }
        
        if(marketplace.equals("Penny") {
            return new PennyCategoryEndpoint();
        }
    }
}

2. ApiCategoryEndpoint Interface

Interface ApiCategoryEndpoint{
    getCategory();
    getCategories(int id);
}

3. Implemtierung des Interfaces

LidlCategoryEndpoint implements ApiCategoryEndpoint{

    @Override
    getCategory(){
        //Code um auf die entsprechende API zuzugreifen
    }
    
    @Override
    getCategories(int id){
        //Code um auf die entsprechende API zuzugreifen
    }
}

Was aber muss in der Methode " ApiCategoryEndpoint getapiCategoryEndpoint(Marketplace marketplace){" zurück gegeben werden?

 

[Barista]

Was aber muss in der Methode " ApiCategoryEndpoint getapiCategoryEndpoint(Marketplace marketplace){" zurück gegeben werden?

Wenn kein passender Category Endpoint gefunden wurde, würde ich eine Exception werfen.

 

[OnDemand]

Gute Idee! Grundsätzlich ist das aber so sinnvoll und Rückgabe des Interdace-Typs "ApiCategoryEndpoint" ist auch eine saubere Lösung?

 

[Barista]

Grundsätzlich ist das aber so sinnvoll und Rückgabe des Interdace-Typs "ApiCategoryEndpoint" ist auch eine saubere Lösung?

Ja.

 

[OnDemand]

Jetzt überlege ich aber noch,: Ich bekomme aus der Factory das passende Interface und kann damit je nach Makrtplatz, die Kategorien holen. Nun liefern die aber alle Implemtierungen, verschiedene Objekte (Json-Sturkturen) zurück.

Eine Möglichkeit wäre, in der Methode direkt nach dem lesen der Response die Daten in ein "allgemeines" Format zubringen. Dann würden die Interface-Implementierungen immer ein identisches Format zurück geben.

Gibts da noch andere Wege?

 

[mrBrown]

In Richting Adapter-Pattern, ganz grob:

zu jedem "Marketplace" einen "Adapter", der Marketplace liefert die spezifischen Daten, der Adapter konvertiert das in das generische Format, damit hat man dann abholen der Daten und Transformieren der Daten getrennt.

Dein ExportCategoryHandler kennt nur die "Adapter", und die verweisen intern jeweils auf den konkreten Marketplace.

 

[OnDemand]

Wie sollte ich die Adapter/Factory gestalten. Ich könnte die mit @Service annotieren und dann mit Autowired oder wie auch immer an der Stelle holen, wo ich es brauche oder? Spricht da was dagegen?

 

[mrBrown]

"holen" klingt immer falsch, geben lassen ist sinnvoller 🙂

Aber @Service und dann Injecten lassen ist sinnvoll, man kann sich auch Listen Injecten lassen, dann musst du nur noch über diese iterieren und dass passende raussuchen.

 

[OnDemand]

Ok danke 🙂

nun hab ich aber noch was, dass ich nicht verstehe.
Ich hab die Klasse Beispiel LidlCategoryEndpoint und NettoCategoryEndpoint. Beide implementieren das Interface CategoryEndpointIF mit der Methode getCategories.

jede der beiden Implementierungen liefert aber unterschiedliche Response Strukturen zurück, sodass ich dann nicht weiß wie ich die umwandeln soll in mein „allgemeines Category Objekt“

Sollte ich eine superclass erstellen, welche dann an die responseobjekte erbt? Das ist mir irgendwie noch nicht so klar, finde auch kein Beispiel im Internet. Adapter pattern bekomm ich irgendwie grad nicht kapiert

 

[mrBrown]

Ganz grob skizziert:

record Category() {}

record LidlCategory() {}

record NettoCategory() {}

class LidlCategoryEndpoint { 
  List<LidlCategory> getCategories() {}
}

class NettoCategoryEndpoint { 
  List<NettoCategory> getCategories() {}
}

class LidlAdapter {
  LidlCategoryEndpoint endpoint; 
  List<Category> getCategories() {
        //lädt LidlCategory mit LidlCategoryEndpoint und konvertiert zu Category
  }
}

class NettoAdapter {
  NettoCategoryEndpoint endpoint; 
  List<Category> getCategories() {
    //lädt NettoCategory mit NettoCategoryEndpoint und konvertiert zu Category
  }
}

 

[OnDemand]

Ahhhhh jetzt versteh ich. Pro Marktplatz ein eigener Adapter, das macht Sinn. Tausend dank 😊 🤌🏼