In che modo la Spring sa dove ottenere l'oggetto proxy deve essere iniettato?

Question

A mia impressione, RmiProxyFactoryBean si suppone che generi un'istanza di oggetto proxy di tipo AccountService che verrà iniettata alla proprietà SimpleObject nel seguente codice nella proprietà accountService.

Quello che non capisco è perché il file XML sembrano indicare primavera per iniettare un oggetto di tipo RmiProxyFactoryBean a accountService proprietà di SimpleObject istanza di un oggetto? Mi aspetto un'istruzione esplicita dal file XML che indichi a Spring come ottenere un'istanza RmiProxyFactoryBean dall'istanza RmiProxyFactoryBean invece di iniettare un'istanza RmiProxyFactoryBean. Trovo questo confuso.

public class SimpleObject { 

    private AccountService accountService; 

    public void setAccountService(AccountService accountService) { 
     this.accountService = accountService; 
    } 
} 


<bean class="example.SimpleObject"> 
    <property name="accountService" ref="accountService"/> 
</bean> 

<bean id="accountService" class="org.springframework.remoting.rmi.RmiProxyFactoryBean"> 
    <property name="serviceUrl" value="rmi://HOST:1199/AccountService"/> 
    <property name="serviceInterface" value="example.AccountService"/> 
</bean> 

Fonte: http://static.springsource.org/spring/docs/2.5.x/reference/remoting.html (vedi 17.2.2.)

Grazie

Answer 1

Un modo più succinto di metterlo è che il RmiProxyFactoryBean implementa l'interfaccia FactoryBean. L'implementazione di tale interfaccia indica alla fabbrica di bean Spring che questa classe è una fabbrica stessa, in modo che Spring invochi il metodo getObject() in quella classe e restituisca il risultato come bean, anziché creare un'istanza della classe stessa e restituire.

Quindi, risposta breve, è un meccanismo integrato di Spring.

Answer 2

Perché Fagioli proxy avvolgono l'oggetto in questione, fanno finta di essere l'interfaccia che viene chiamato (e quindi in seguito chiameremo questa interfaccia).

Il RmiProxyFactoryBean restituisce un oggetto proxy in modo che quando il codice pensa che sta chiamando un metodo su vostra classe example.AccountService, in realtà è stato chiamato su un fagiolo con la stessa interfaccia come interfaccia example.AccountService come specificato qui:

<bean id="accountService" class="org.springframework.remoting.rmi.RmiProxyFactoryBean"> 
    ... 
    <property name="serviceInterface" value="example.AccountService"/> 
</bean> 

dire che c'era un metodo sull'interfaccia denominata example.AccountService.reconcile(Long amount) (solo per fare un esempio) ...

Se avete chiamato questo normalmente il metodo chiamando sarebbe solo spingerlo nello stack. Ma se l'oggetto example.AccountService viene restituito da RmiProxyFactoryBean come sopra, sarà racchiuso in un bean proxy. Questo bean proxy ha un metodo al suo interno che è anche chiamato reconcile e ha anche un argomento di Long amount, che lo rende indistinguibile dal bean originale example.AccountService che esso avvolge. In questo modo il bean proxy può avere il codice che esegue, prima, dopo o al posto del codice che si trova nel metodo effettivo example.AccountService.reconcile(Long amount).

I bean proxy provengono da un modo completamente diverso di programmazione denominato Aspect Oriented Programming (AOP) che si occupa di problemi trasversali; cioè codice che non sembra chiaramente rientrare nei confini della normale separazione OOP delle preoccupazioni. Alcune di queste preoccupazioni sono, ad esempio, la demarcazione delle transazioni, la sicurezza e la registrazione.

Sembra che lo stiate facendo manualmente sopra, ma a volte è più facile intrecciarli in fase di esecuzione utilizzando SpringAOP che ha una lingua per selezionare e applicare i bean proxy al codice esistente.

Tuttavia, prendere nota per programmare su interfacce anziché programmare su solo classi.