Cosa è richiesto per un ambito in un'infrastruttura di iniezione?

Limita l'uso degli ambiti o più concretamente Usa gli ambiti per il solo cablaggio .

Se usato correttamente, gli ambiti possono ridurre molta piastra della caldaia di fabbrica. Io uso gli ambiti per collegare tra loro sottoprocessi che potrebbero aver bisogno di accedere al suo nome e ai suoi argomenti. È simile al RequestScope s fornito da Guice e Spring.

Ma gli scope sono effettivamente una mappa locale filettata di una stringa all'oggetto. Questo è praticamente un deposito di variabili globali. Questo è il motivo per cui limito l'utilizzo dell'ambito.

Questo porta al corollario:

Nascondi gli ambiti o più in generale Nascondi il tuo framework DI

Poiché gli ambiti (e framework DI) sono essenzialmente Depositi di variabili globali , preferisco incapsulare il DIF in modo tale che l'unica cosa che sa che esiste un DIF sia il metodo principale.

Per fare questo, definisco la mia interfaccia di ambito e il mio ProcessFactory che definisco all'interno di un modulo Guice.

Per questo motivo, il mio gestore dei processi è privo di riferimenti a Guice. In realtà, è poco più di questo metodo:

void run(final ProcessContext context) {
    try {
        this.scope.enter(context.processArgs());
        this.factory.create(args.processName());
    } finally {
        this.scope.exit();
    }
}

Ecco il modulo Guice completo che lega e nasconde il mio uso di un Guice. Implementa le mie interfacce ProcessScope e ProcessFactory. Lega @ProcessParameters in modo che possano essere iniettati e anche alcuni oggetti di convenienza (@ProcessName String e ProcessConfig).

public class ProcessRunnerModule extends AbstractModule {
    private static final String PROCESS_RUN_SCOPE = "ProcessRunScope";

    /**
     * Objects of type Map<String, Object> parameterized by @ProcessParameters
     * are injected in the ProcessRunScope
     */
    static final Key<Map<String, Object>> PROCESS_PARAMETERS_KEY;
    static {
        final TypeLiteral<Map<String, Object>> MAP_TYPE = new TypeLiteral<Map<String, Object>>() {
        };
        PROCESS_PARAMETERS_KEY = Key.get(MAP_TYPE, ProcessParameters.class);
    }


    /**
     * Wraps Guice scope to ProcessScope. Injects the @ProcessParameters into guice
     */
    private static class GuiceScopeAdapter implements ProcessScope {

        private final SimpleScope scope;

        @Inject @SuppressWarnings("unused")
        public GuiceScopeAdapter(@Named(PROCESS_RUN_SCOPE) SimpleScope scope) {
            this.scope = scope;
        }

        @Override
        public void enterScope(Map<String, Object> parameters) {
            scope.enter();
            scope.seed(PROCESS_PARAMETERS_KEY, parameters);
        }

        @Override
        public void exitScope() {
            scope.exit();
        }
    }

    /**
     * Processes are run and bound in @ProcessRunScope.
     */
    protected void configure() {
        final SimpleScope processRunScope = new SimpleScope();
        bindScope(ProcessRunScope.class, processRunScope);
        bind(SimpleScope.class)
            .annotatedWith(Names.named(PROCESS_RUN_SCOPE))
            .to(processRunScope);
    }

    /**
     * This wraps Processes bound via MapBinder to a ProcessFactory
     */
    @Provides @Singleton
    ProcessFactory createProcessFactory(final Map<String, Provider<Process>> processFactories) {
        log.info("Instantiating process factory", "known-processes", processFactories.keySet());
        return new ProcessFactory() {
            @Override
            public Process create(final String name) {
                return processFactories.get(name).get();
            }
        };
    }

    /**
     * ProcessRunner does not know about Guice
     */
    @Provides @Singleton
    ProcessRunner createProcessRunner(
            final ProcessScope processScope,
            final ProcessFactory processFactory) {

        return new ProcessRunner(processScope, processFactory);
    }


    /**
     * Convienience: bind a @ProcessName extracted from the @ProcessParameters
     */
    @Provides @ProcessName @ProcessRunScope
    String bindProcessName(final @ProcessParameters Map<String, Object> params) {
        return params.get(ProcessRunner.PROCESS_NAME_KEY).toString();
    }

    /**
     * Convienience: bind a ProcessConfig wrapping the @ProcessParameters
     */
    @Provides @ProcessRunScope
    ProcessConfig createParamHelper(final @ProcessParameters Map<String, Object> params) {
        return new ProcessConfig(params);
    }
}

Non iniettare oggetti con un ambito più piccolo dell'oggetto in cui lo si inietta. In tal caso, iniettare una fabbrica in modo che il dipendente possa gestire l'ambito.

Tutti gli altri ambiti possono essere gestiti tramite il framework DI. Il framework DI dovrebbe essere in grado di interrogare qualche oggetto o metodo che fornisci per vedere se dovrebbe ricreare nuovamente una nuova istanza oppure no.

In altre parole, un framework DI dovrebbe delegare una gestione complessa dell'ambito all'utente.