Service locator vs Iniezione delle dipendenze?

1

Ho una classe che funge da adattatore tra una richiesta HTTP e la richiesta di dominio personalizzato della nostra Applicazione. Quindi ogni elemento di richiesta Http: URI, intestazioni, contenuti sono mappati ai nostri elementi dell'oggetto dominio personalizzati.

Un altro DataMapper di classe che esegue la serializzazione / deserilizzazione del contenuto. Questa classe viene utilizzata dall'adattatore per codificare / decodificare il contenuto di HttpRequest.

DataMapper

public abstract class DataMapper {

    /**
     * Factory method to create Data mapper types
     * @param mediaType: Type for which Datamapper is to be created
     * @return
     */
    public static DataMapper getMapper(String mediaType) {
        MediaType type = MediaType.findType(mediaType); 

        switch(type) {

        case JSON:
            return new JSONDataMapper();

        case XML:
            return new XMLDataMapper();

        }
        throw new IllegalArgumentException("Invalid media Type: " + mediaType );

    }

    /**
     * Serialize general obj to XML
     * 
     */
    public abstract String serialize(Object ob);

    /**
     * Deserialize general obj to XML
     * 
     */
    public abstract Object deserialize(String obj);

}

Adapter

public class HttpToCustomDomainConverter {

    private DataMapper dataMapper;     

    /**
     * @param httpRequest: HTTP request
     * @param domainReq: Domain request 
     * @return nothing
     * @return Converts HTTP request to Domain Request
     */
    public void httpToCustomDomainRequest(HttpServletRequest httpRequest, CustomDomainRequest domainReq) {

        domainReq.setRequestIdentifier(httpRequest.getHeader("X-Domain-RI"));

        String acceptType = httpRequest.getHeader("Accept");
        String contentTypeHeader = httpRequest.getContentType();

        String serializedPayload = getPayload(httpRequest, contentType);

        dataMapper = DataMapper.getMapper(contentType);

        switch(httpMethod){

        case POST:
        case PUT:

            Object content = dataMapper.deserialize(serializedPayload));
            domainReq.setContent(content);

            break;

        case GET:
        case DELETE:
            break;
        }

        // ........
   }   
}

Domanda:

Voglio che il mio codice segua i principi SOLID, quello di cui sono preoccupato è Dependency Injection.

dataMapper = DataMapper.getMapper(contentType);
dataMapper.deserialize(serializedPayload));

Qui estraggo l'header http requestContentType e poi trovo il corrispondente DataMapper (XML o JSON) e poi serializzo / deserializza il contenuto.

Quindi devo passare l'implementazione specifica di DataMapper (XmlDataMapper o JsonDataMapper) nel costruttore di questa classe per seguire DI.

O il mio codice è corretto nell'individuare DataMapper in fase di esecuzione in base a contentType in richiesta.

Qualsiasi consiglio è apprezzato.

    
posta Siddharth Trikha 04.08.2017 - 13:24
fonte

1 risposta

4

La tua linea,

I want my code to follow SOLID principles, the one I am worried about in this is Dependency Injection.

è confuso. Sei preoccupato che non stia usando l'iniezione di dipendenza (DI)? Se è così, direi che hai ragione a pensarlo, ma potresti non avere ragione di essere preoccupato.

Usando questo localizzatore di servizi, invece di usare DI, è possibile rendere più difficile il test del codice, poiché non è possibile prendere in giro quel mappatore di dati durante i test. Tuttavia, se questi mappatori sono privi di effetti collaterali, potrebbe non essere necessario prenderli in giro. I puristi di DI, come me, potrebbero rabbrividire a questo localizzatore, ma in modo pragmatico potrebbe essere la scelta migliore qui.

    
risposta data 04.08.2017 - 14:02
fonte