Utilizzo di Spring come framework di iniezione delle dipendenze con il gioco 2.4.x?

Question

Sto esplorando play-scala 2.4.2 e sto cercando di far funzionare il DI primitivo. Vedo che ci sono molti cambiamenti in gioco 2.4.x e il vecchio modo di scavalcare GlobalSettings.getControllerInstance sembra non essere più un'opzione.

Mi sono imbattuto in questo progetto https://github.com/jroper/play-spring, ma sembra essere più di un POC che dimostra che Spring DI è possibile, ma non sembra essere facile come nelle precedenti versioni di gioco. Sarà questo il meccanismo di integrazione primaverile per le versioni di gioco attuali e future o un meccanismo o un quadro più semplice può essere previsto a breve dalla community di gioco?

Answer 1

Si prega di seguire i seguenti passi:

Step1: Aggiungere le dipendenze di primavera in build.sbt file.

libraryDependencies += "org.springframework" % "spring-context" % "4.1.6.RELEASE" 
libraryDependencies += "org.springframework" % "spring-core" % "4.1.6.RELEASE" 
libraryDependencies += "org.springframework" % "spring-beans" % "4.1.6.RELEASE" 
libraryDependencies += "org.springframework" % "spring-aop" % "4.1.6.RELEASE" 

Step2: Creare una nuova classe (ApplicationGlobalSettings.java) e che implementa con GlobalSettings classe.

package com.ranga.global.settings; 

import org.springframework.context.ConfigurableApplicationContext; 
import org.springframework.context.support.ClassPathXmlApplicationContext; 

import play.Application; 
import play.GlobalSettings; 
public class ApplicationGlobalSettings extends GlobalSettings { 


private static final String APPLICATION_CONTEXT_XML = "applicationContext.xml"; 
private ConfigurableApplicationContext applicationContext; 

@Override 
public void beforeStart(Application application) {  
    super.beforeStart(application); 
} 

@Override 
public void onStart(Application application) {  
    super.onStart(application);  
    applicationContext = new ClassPathXmlApplicationContext(APPLICATION_CONTEXT_XML);   
} 

@Override 
public void onStop(Application application) {  
    super.onStop(application); 
    if(applicationContext != null) { 
     applicationContext.close(); 
    } 
} 

}

Fase 3: Creare un nuovo file di configurazione di primavera sotto cartella conf (applicationContext.xml) conf \ applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:context="http://www.springframework.org/schema/context" 
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd 
         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> 

    <context:component-scan base-package="com.ranga.services, com.ranga.daos"/> 

</beans> 

Step4 : Aggiungi la posizione del file GlobalSettings appena creata alla a file di configurazione di pplication (conf/application.conf).

.....some more configuration here..... 
# Global Objects class 
application.global=com.ranga.global.settings.ApplicationGlobalSettings 

Fase 5: Creare una nuova classe di servizio nell'ambito del pacchetto com.ranga.service (HelloWorldService.java).

package com.ranga.services; 
import javax.inject.Inject; 
import org.springframework.stereotype.Service; 

import com.ranga.daos.HelloWorldDAO; 
@Service 
public class HelloWorldService { 

    @Inject 
    private HelloWorldDAO helloWorldDAO; 

    public String sayHello() { 
     return helloWorldDAO.sayHello(); 
    } 
} 

Step6: Creare una nuova classe dao sotto com.ranga.daos pacchetto (HelloWorldDAO.java).

package com.ranga.daos; 

import org.springframework.stereotype.Repository; 
@Repository 
public class HelloWorldDAO { 
    public String sayHello() { 
     return "Hello Ranga!"; 
    } 
} 

Step7: Infine iniettare il HelloWorldService in Application.java file di.

package com.ranga.controllers; 

import javax.inject.Inject; 

import org.springframework.beans.factory.annotation.Autowired; 

import com.ranga.services.HelloWorldService; 

import play.*; 
import play.mvc.*; 

import views.html.*; 

public class Application extends Controller { 

    @Inject 
    private HelloWorldService helloWorldService; 

    public Result index() {   
     return ok(index.render(helloWorldService.sayHello())); 
    } 
} 

Step8: Infine modificare il codice del file index.scala.html.

@(message: String) 

<h1>@message</h1> 

Ora fatto .. eseguire l'applicazione.

Answer 2

L'ultima versione di Play:

Creare la classe globale (Old globale di GlobaSettings estesi):

@Singleton 
public class Global { 

    private static final String APPLICATION_CONTEXT = "applicationContext.xml"; 

    private ConfigurableApplicationContext applicationContext; 

    @Inject 
    public Global(ApplicationLifecycle lifecycle) { 
     applicationContext = new ClassPathXmlApplicationContext(APPLICATION_CONTEXT_XML); 
     lifecycle.addStopHook(() -> { 
      applicationContext.close(); 
      return F.Promise.pure(null); 
     }); 
    } 

} 

Creare il ConfigurableApplicationContextModule classe:

public class ApplicationContextModule extends AbstractModule { 

    @Override 
    protected void configure() { 
     bind(Global.class).asEagerSingleton(); 
    } 

} 

In application.conf add this:

play.modules.enabled += "config.ApplicationContextModule" 

Creare file di applicationContext.xml:

<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans" 
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
     xmlns:context="http://www.springframework.org/schema/context" 
     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd 
         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> 

     <context:component-scan base-package="services, dao"/> 

</beans> 

Dopo la creazione di quello che abbiamo detto da Ranga

Answer 3

Solo nel caso si può aiutare qualcuno, ho anche lavorato su una soluzione che funziona in base al largo del progetto di jroper: https://github.com/jroper/play-spring. La chiave è stato quello di utilizzare la funzione di scansione di primavera per "caricare" le classi di gioco:

ctx.scan(packages:_*)

con i pacchetti del gioco di default:

def defaultPackages(): Seq[String] = Seq("router", "play", "controllers")

La soluzione funziona con 1 trucco: è necessario per aggiungere @ javax.inject.Named accanto alle annotazioni @Singleton nelle classi Play in modo che Spring possa eseguirne la scansione e caricarle (ovvero è necessario "forgiare" la versione di gioco che si sta utilizzando, ma è piuttosto piccola e facile modificare). Così qui è la mia applicazione di esempio con lo SpringApplicationLoader: https://github.com/remithieblin/play24_spring