Limiti dell'iniezione di dipendenza

Analisi del problema:

... sometimes, it's difficult to get the dependencies to where they're needed and sometimes, it's plain impossible.

... An extreme example is making MyResponse.toString() return some JSON...

... stacktrace should only be shown to testers ...

... Obviously, this dependency can be included in MyResponse or provided as arguments...

Dal tuo contesto, mi sembra che Dependency Injection potrebbe non essere il problema principale. Invece, IMO forse il design delle tue classi sta diventando troppo complesso, essendo difficile gestire le dipendenze e le relazioni. Inoltre, credo che dovresti rivedere la struttura generale delle classi e verificare se la tua applicazione sta seguendo tutte le migliori pratiche e principi. Ad esempio:

I can provide a properly configured Gson, which takes care about the conditional stacktrace hiding and the localized end-user message generation.

Sembra che questo oggetto possa violare il principio di responsabilità singola. Facendo cose del genere, stai influenzando negativamente la progettazione dell'applicazione, rendendo difficile l'ulteriore manutenzione.

Quindi, dando un'occhiata al tuo problema:

But oftentimes, it doesn't work well and I end up passing lots of arguments, or passing needlessly big dependency aggregates, or creating single-use aggregates. In the end, it feels like I'm overusing DI as it starts to make the code more ugly rather then nicer.

Suggerisco di rivedere la progettazione dell'applicazione e provare a utilizzare schemi di progettazione che possono aiutare a gestire dipendenze o astrazioni. Ad es .: puoi provare a usare:

• Pattern di facciata: il client chiama il servizio, che nasconde un Api più complesso, aggregando o gestendo parti della risposta;
• Schema mediatore: oggetti che semplificano le relazioni tra molti oggetti che potrebbero funzionare insieme per alcune attività;
• Motivo decoratore: aggiunge dinamicamente comportamento agli oggetti in fase di runtime;
• Verifica tutte le classi e i moduli e assicurati che non violino anche altri principi di solidità;

Per ora posso pensare a questi modelli, se avrò più idee modificherai la mia risposta.

Facciata: link

Mediatore: link

Decoratore : link

Dopo aver letto le tue modifiche, ti suggerisco il modello Decorator per il tuo caso. Di seguito fornisco alcuni esempi di codice basati su esempi di risposta.

class MyResponse {
    //list of Dtos or exception
}

interface MyResponseProcessor {
    MyResponse processResponse(MyResponse originalResponse);
}

interface MyResponseProcessorDecorator implements MyResponseProcessor {
    private MyResponseProcessor processor;

    MyResponse processResponse(MyResponse originalResponse);
}

class MyResponseBaseProcessor implements MyResponseProcessor {

    MyResponse processResponse(MyResponse originalResponse) {
        //basic processing of your response information
    }
}

class MyResponseStackTraceProcessor implements MyResponseProcessorDecorator {
    private MyResponseProcessor processor;

    public MyResponseStackTraceProcessor(MyResponseProcessor processor) {
        this.processor = processor;
        //Maybe inject some object capable of retrieving current user's permissions,
        //in order to know if should hide stack trace or not
    }

    MyResponse processResponse(MyResponse originalResponse) {
        //transforms original response, by removing info
        //depending on user's role of access
        //Returns a new response with the transformed information
    }
}

class MyResponseLocalizedErrorMessageProcessor implements MyResponseProcessorDecorator {
    private MyResponseProcessor processor;

    public MyResponseStackTraceProcessor(MyResponseProcessor processor) {
        this.processor = processor;
        //Inject other objects capable of loading current localization info
    }

    MyResponse processResponse(MyResponse originalResponse) {
        //transforms original response, by loading appropriate
        //localized string according to the error message within the 
        //original response;
        //Returns new MyResponse with error message added;
    }
}

interface MyResponseSerializer {
    String serialize(MyResponse response);
}

class MyResponseJsonSerializer implements MyResponseSerializer {
    String serialize(MyResponse response) {
        //only gets the info and convert them to Json
    }
}

class MyResponseXmlSerializer implements MyResponseSerializer {
    String serialize(MyResponse response) {
        //only gets the info and convert them to Xml
    }
}


//Example of use

String getSerializedResponse(MyResponse response) {

    //Decorations for response processor
    MyResponseProcessor processor = new MyResponseBaseProcessor();
    processor = new MyResponseStackTraceProcessor(processor);
    processor = new MyResponseLocalizedErrorMessageProcessor(processor);

    MyResponse processedResponse = processor.processResponse(response);

    MyResponseSerializer serializer = new MyResponseJsonSerializer();

    return serializer.serialize(processedResponse);
}