Iniezione di dipendenza Grails al di fuori dei servizi?

Question

Ho un'applicazione Grails che deve eseguire una strategia che verrà probabilmente sostituita nel tempo. So che Spring è alla base di Grails, quindi mi chiedevo se avessi accesso al contenitore IoC di Spring in modo che potessi esternare la dipendenza effettiva in un file xml (nota: non l'ho mai fatto, ma so solo che, quindi potrei esserlo manca qualcosa). Il mio obiettivo è quello di essere in grado di fare qualcosa di simile al seguente:

class SchemaUpdateService { 
public int calculateSomething(){ 
ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml"); 
IStrategy strat = (IStrategy) ctx.getBean("mystrat"); 
} 
} 

E poi la mappa l'implementazione appropriata nel file beans.xml. Presumo che questo sia supportato in Grails. Qualcuno ha qualche documentazione su come potrebbe funzionare? Ho davvero bisogno della libreria IoC Spring e funzionerà? Grazie!

Answer 1

Si definiscono i bean in resources.xml o resources.groovy. I graal documentation sono molto chiari su come accedere al contesto dell'applicazione Spring.

Answer 2

È possibile accedere al contesto applicativo da qualsiasi Grails manufatto utilizzando

ApplicationContext ctx = grailsApplication.mainContext 

È quindi possibile utilizzare questo per recuperare qualunque fagioli che ti interessa:

IStrategy strat = (IStrategy) ctx.getBean("mystrat") 

In classi che non lo fanno avere accesso a grailsApplication, è possibile utilizzare un helper come il seguente per accedere al contesto dell'applicazione e ai relativi fagioli

class SpringUtils { 

    static getBean(String name) { 
     applicationContext.getBean(name) 
    } 

    static <T> T getBean(String name, Class<T> requiredType) { 
     applicationContext.getBean(name, requiredType) 
    } 

    static ApplicationContext getApplicationContext() { 
     ApplicationHolder.application.mainContext 
    } 
} 

Tuttavia, questo dovrebbe essere necessario solo se è necessario recuperare diverse implementazioni dello stesso bean in fase di esecuzione. Se il chicco di richiesta è noto al momento della compilazione, basta collegare i fagioli insieme in resources.xml o resources.groovy

Answer 3

Prima di tutto, si desidera definire la vostra strategia nel vostro grails-app/conf/spring/resources.groovy:

beans = { 
    myStrat(com.yourcompany.StrategyImpl) { 
     someProperty = someValue 
    } 
} 

Poi, è sufficiente def l'una proprietà con lo stesso nome nel vostro servizio:

class SomeGrailsService { 
    def myStrat 

    def someMethod() { 
     return myStrat.doSomething() 
    } 
} 

In ogni manufatto Grails (come i servizi e le classi di dominio), Grails darà automaticamente il myStrat proprietà il valore corretto. Ma non dimenticare, in un test di unità dovrai dargli un valore manualmente poiché l'auto-cablaggio non avviene nei test unitari.

Al di fuori di un manufatto Grails, è possibile usare qualcosa come:

def myStrat = ApplicationHolder.application.mainContext.myStrat 

In Grails 2.0, Graeme et al stanno deprecando l'utilizzo delle *Holder classi (come ApplicationHolder e ConfigurationHolder), quindi sono Non so esattamente quale sarebbe l'approccio di Grails 2.0 ...