Il modo migliore per iniettare una classe i cui esemplificazione non può essere controllato?

Question

Sono abbastanza nuovo per Guice quindi speriamo che questo non è una domanda ovvia ...

ho a che fare con un quadro che crea un'istanza dinamicamente una delle mie classi di applicazione (chiamiamolo C) utilizzando la riflessione, quindi non ho alcun controllo sulla sua esemplificazione. Inoltre, non esiste un modo facile per me accedi un C appena creato dopo che il quadro è instantitated esso. è qui che cosa C sarà simile:

    public class C implements I {

        public C() {
            // this ctor is invoked by the framework so can't use DI here?
        }        

        public void initialize() {
            // this is a post instantiation hook which the f/w will invoke
        }

        private void m() {
            Dependency d = Dependency.getInstance();
            d.doSmth();
        }
    }

Vorrei C acquisire Dependency usando DI. Qui Dependency è chiaramente un singoletto, ma questo non deve essere il caso in generale.

Ho messo a punto due soluzioni possibili, nessuno dei quali si sente molto ordinato, quindi ho pensato di chiedere agli esperti:

1. iniezione statico. Fatico a vedere come questo migliora drasticamente il servizio di individuazione anti-modello però -. Io alla fine con campi statici non definitivi, che poteva essere manipolati esternamente ... hmmm

2. Il framework supporta un gancio per C si inizializzi istanziazione palo (il metodo initialize() mostrato sopra). Questo metodo potrebbe auto-iniezione nuova istanza creata usando iniezione setter.

Con 2, credo che questo mezzo alterabilità più esterno ma almeno espone la dipendenza un po 'più esplicito per cose come test di unità. Il problema è: come faccio a mettere le mani sul Guice Injector in quel caso (a corto di fare affidamento su un altro localizzatore di servizio)? Ho anche letto (e tendo a concordare con) che fare esplicito riferimento ad iniettore per tutta codice di applicazione è dubbia pratica.

Il tuo intuizione sarebbe molto apprezzato.

Molte grazie,
Christian

Answer 1

Si potrebbe provare l'iniezione in modo statico fornitori in iniezione C. Statico più difficile da test. Ma i fornitori rendono possibile per Guice per convalidare le dipendenze con entusiasmo, mentre la creazione di loro pigramente.

public class C implements I {
  @Inject static Provider<Dep1> dep1Provider;
  @Inject static Provider<Dep2> dep2Provider;

  ...

  public void initialize() {
    Dep1 dep1 = dep1Provider.get();
    Dep2 dep2 = dep2Provider.get();
    ...
  }
}

Answer 2

Se fate la vostra Guice iniettore a disposizione dalla variabile statica e metodi di accesso statici si può risolvere in questo modo:

public class C implements I {

    public C() {
        // this ctor is invoked by the framework, you can't do injection here.
    }        

    public void initialize() {
        MyGuice.getInjector().inject(this);
    }

    @Inject
    protected void init(Dep1 dep1, Dep2 dep2) {
        this.dep1 = dep1;
        this.dep2 = dep2;
    }

    private void m() {
        dept1.doSmth();
    }
}

La chiamata statica è un po 'un anti-modello, è possibile rimuovere che la dipendenza con un semplice annotazione che si prende cura del post iniezione del costruttore se si è disposti a utilizzare una soluzione che fa tessitura codice o una fase di post di compilazione. In questo modo è possibile iniettare tutti gli oggetti, anche se non hanno un metodo di inizializzazione. È possibile trovare un esempio di questo qui:. Come iniettare oggetto del modello con AspectJ

@Configurable
public class C implements I {

    public C() {
        // this ctor is invoked by the framework, you can't do injection here.
    }        

    @Inject
    protected void init(Dep1 dep1, Dep2 dep2) {
        this.dep1 = dep1;
        this.dep2 = dep2;
    }

    private void m() {
        dept1.doSmth();
    }
}