A Match made in Heaven

Eine Alternative zur Konfiguration mit XML ist die Nutzung von Spring JavaConfig. Dieser Ansatz erlaubt die Definition von Spring Beans mithilfe von Java-Klassen. Die Klassen enthalten dann die Methoden, um Spring Beans zu erzeugen. Auf die Ergebnisse der Methoden werden natürlich die Spring-Bean-Regeln bezüglich Scopes oder Erweiterungen wie AOP angewendet. Diese Erweiterung kann auch mit Scala genutzt werden, sodass dann die Spring Beans durch Scala-Code erzeugt werden. Listing 4 zeigt ein Beispiel: Die Scala-Klasse ist mit @Configuration annotiert, sodass sie als Spring-Konfiguration erkannt wird. Spring Beans aus anderen Konfigurationen – auch XML-Konfigurationsdateien – werden durch @Autowired injiziert und können zum Erzeugen weiterer Spring Beans genutzt werden. Obwohl diese Objekte nicht verändert werden sollten, müssen sie leider für Scala als veränderlich (var) deklariert werden. Es muss zudem eine Vorbelegung mit _ erfolgen, weil es sonst zu einem Compiler-Fehler kommt. Die Ergebnisse der mit @Bean annotierten Methoden sind dann die Spring Beans.

Listing 4: Spring JavaConfig mit Scala
@Configuration
class ScalaConfig {
  @Autowired
  var dataSource: DataSource = _
  @Bean
  def transactionManager() =
    new DataSourceTransactionManager(dataSource)
  @Bean
  def customerDAO() = new CustomerDAO(dataSource)
}

Die Konfiguration ist kurz, kompakt und ausdrucksstark, sodass sie fast wie eine Scala-Spring-DSL wirkt. Der Aufwand für eine eigene Spring-Konfigurationssprache auf Basis von Scala ist also entbehrlich. Der Entwickler kann so alle Features von Scala für das Erzeugen der Spring Beans nutzen. Natürlich kann er auch auf Konfigurationsdaten beispielsweise aus .properties-Dateien zugreifen, sodass auch Benutzernamen oder URLs konfiguriert werden können. Aber eine Änderung in der Scala-Konfiguration bedingt ein erneutes Kompilieren und Deployen der Anwendung, was aufwändig sein kann.

Die letzte Möglichkeit für die Konfiguration von Spring ist die Nutzung von Annotationen. Dabei werden die Klassen der Spring Beans mit entsprechenden Annotationen versehen. Listing 5 zeigt ein entsprechendes Beispiel: Die Klasse wird durch @Component zu einer Spring Bean. Mit @Autowired werden andere Spring Beans injiziert. Auch hier muss die Variable mit var als änderbar deklariert sein und einen initialen Wert haben.

Listing 5: Spring-Annotationen mit Scala
@Component
class CustomerDAO {
 @Autowired
  var dataSource: DataSource = _ 
}

Natürlich haben die Klassen dann Abhängigkeiten zu Spring. Aber dieser Ansatz kann auch mit einer Klasse ohne Annotationen oder andere Abhängigkeiten zu Spring wie

class CustomerDAO(dataSource: DataSource) {}

genutzt werden. Dazu muss Spring wie in Listing 6 dargestellt konfiguriert werden. So nutzt Spring grundsätzlich Konstruktoren für Dependency Injection. Außerdem werden Spring Beans aus allen Klassen erzeugt, deren Namen auf DAO enden und die aus dem Package de.adesso.scalaspring.dao kommen.

Listing 6: Namenskonvention

Themen der foglenden Seiten:

  • Serviceabstraktion

  • Spring JDBC Callbacks mit Java
  • Spring JDBC mit Scala Funktionen
  • Aspektorientierte Programmierung (AOP)
  • Transactional Funktion
  • Infos zum Autoren
Kommentare

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht.