Używanie Spring jako architektury wtrysku zależności z grą 2.4.x?

Question

Eksploruję play-scala 2.4.2 i staram się, aby DI pracował z nią. Widzę, że jest wiele zmian w grze 2.4.x i stary sposób nadpisywania GlobalSettings.getControllerInstance wydaje się już nie być opcją.

Natknąłem się na ten projekt: https://github.com/jroper/play-spring, ale wydaje się, że jest to bardziej POC, który udowadnia, że ​​Spring DI jest możliwy, ale nie wydaje się tak łatwy, jak we wcześniejszych wersjach gry. Czy będzie to mechanizm wiosennej integracji dla obecnych i przyszłych wersji gry, czy prostszy mechanizm lub framework, który może się wkrótce wydarzyć od społeczności graczy?

Answer 1

proszę wykonać następujące kroki:

Krok 1: Dodaj zależności sprężynowe build.sbt pliku.

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" 

Krok 2: Utwórz nową klasę (ApplicationGlobalSettings.java) i że realizuje z GlobalSettings klasowych.

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(); 
    } 
} 

}

Krok 3: Utwórz nowy plik konfiguracyjny sprężyna pod conf folderu (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 : Dodaj nowo utworzoną lokalizację pliku GlobalSettings do a plik konfiguracyjny pplication (conf/application.conf).

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

Krok 5: Utwórz nową klasę usług w ramach pakietu 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: Tworzenie nowej klasy dao pod com.ranga.daos pakiet (HelloWorldDAO.java).

package com.ranga.daos; 

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

Step7: Wreszcie wstrzyknąć HelloWorldService w Application.java pliku.

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: Wreszcie modyfikować index.scala.html kod pliku.

@(message: String) 

<h1>@message</h1> 

Teraz gotowe .. uruchom aplikację.

Answer 2

Najnowsza wersja Play:

Utwórz klasę Global (Old Globalny niż udzielonych GlobaSettings):

@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); 
     }); 
    } 

} 

utworzyć klasy ConfigurableApplicationContextModule:

public class ApplicationContextModule extends AbstractModule { 

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

} 

W application.conf dodatku to:

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

utworzyć plik 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> 

Po utworzeniu co stwierdzono powyżej przez Ranga

Answer 3

wszelki wypadek może komuś pomóc, ja również pracował nad rozwiązaniem, który pracuje w oparciu off projektu jroper za: https://github.com/jroper/play-spring. Kluczem było użyć funkcji skanowania sprężyna w celu "obciążenia" klas zaawansowania:

ctx.scan(packages:_*)

z pakietami domyślnego Play:

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

Rozwiązanie współpracuje z 1 Hack: trzeba aby dodać @ javax.inject.Named obok adnotacji @Singleton w klasach Play, aby Spring mógł je przeskanować i załadować (tj. musisz "rozwidlić" wersję Play, której używasz, ale jest to raczej małe i łatwe zmiana). Więc tutaj jest moja aplikacja próbka z SpringApplicationLoader: https://github.com/remithieblin/play24_spring