Am Ende dieses Beitrags kommt eine universeller Konfigurations-Helper für das Springframework heraus.
org/tangram/spring/PropertySplittingPlaceholderConfigurer.java
Aber warum man so etwas brauchen könnte, wollte ich kurz an zwei oder vier (je nachdem wie man es zählen möchte) zeigen.
Bisher habe ich das Springframework und die jeweiligen Persistenzschicht immer komplett unabhängig voneinander genutzt: Java Persistence API (JPA) konfiguriert man über eine persistence.xml und Java Data Objects (JDO) über eine jdoconfig.xml. ORM Integrationen habe ich auch im zusammenspiel mit Spring MVC nicht benötigt. - Dachte ich.
Aber insbesondere durch Cloud-Umgebungen habe ich nun lernen müssen, daß der Weg über diese Dateien eigentlich nicht gerade "best practice" ist und eher für einfache Situationen taugt.
Wenn man dann endlich neben der Nutzung der Google App Engine auch mal einen Ausflug nach Cloudbees und OpenShift macht, tritt nämlich ein kleines Problem zutage: Die Werte in den oben genannten Dateien können nicht, wie alles andere, das ich in Spring "zusammenstecke", mit Platzhalter versehen werden, die erst zur Laufzeit des Systems aufgelöst werden.
Durch diese Ersetzung, wie sie z.B. Bei Spring quasi automatisch passiert - paßt sich ein ein grundsätzlich vorkonfiguriertes System dann in seine Laufzeitumgebung ein. - Bis auf die Persistenzschicht in meinem Fall.
Als einfachstes Beispiel nehmen wir mal die Verbindungsdaten zu einer Datenbank unter OpenShift. Diese sollte man am sinnvollsten aus den Umgebungsvariablen lesen, sagt die "best practice" von OpenShift.
JDO auf OpenShift
Also nimmt man beim Einsatz von JDO die Werte<persistence-manager-factory name="transactions-optional">
<property name="javax.jdo.PersistenceManagerFactoryClass"
value="org.datanucleus.api.jdo.JDOPersistenceManagerFactory"/>
<property name="javax.jdo.option.ConnectionURL"
value="mongodb://localhost:8111/db"/>
<property name="javax.jdo.option.ConnectionUserName" value="u"/>
<property name="javax.jdo.option.ConnectionPassword" value="p"/>
</persistence-manager-factory>
aus der jdoconfig.xml komplett heraus und übergibt sie bei der Instanziierung der PersistenceManagerFactory mit:
factory =
JDOHelper.getPersistenceManagerFactory(jdoConfigOverrides,
"transactions-optional");
und diese jdoConfigOverrides bezieht man dann aus der Spring-Configuration, wo sie von den Ersetzungen auf Basis von Umgebungswerten profitieren:
<bean id="jdoConfigOverrides" class="java.util.HashMap">
<constructor-arg>
<map>
<entry key="javax.jdo.option.ConnectionURL"
value="mongodb://${OPENSHIFT_MONGODB_DB_HOST}:${OPENSHIFT_MONGODB_DB_PORT}/test"/>
<entry key="javax.jdo.option.ConnectionUserName"
value="${OPENSHIFT_MONGODB_DB_USERNAME}"/>
<entry key="javax.jdo.option.ConnectionPassword"
value="${OPENSHIFT_MONGODB_DB_PASSWORD}"/>
</map>
</constructor-arg>
</bean>
JPA auf OpenShift
Entsprechend geht man bei JPA vor und nimmt die Werte<persistence-unit name="openjpa" transaction-type="RESOURCE_LOCAL">
<provider>org.apache.openjpa.persistence.PersistenceProviderImpl</provider>
<exclude-unlisted-classes>false</exclude-unlisted-classes>
<properties>
<property name="javax.persistence.jdbc.url"
value="jdbc:postgresql://localhost:5432/postgres"/>
<property name="javax.persistence.jdbc.user" value="un"/>
<property name="javax.persistence.jdbc.password" value="pw"/>
</properties>
</persistence-unit>
auch hier aus der Konfigurationsdatei heraus und fügt sie in die Spring-Konfiguration ein:
<bean id="jpaConfigOverrides" class="java.util.HashMap">
<constructor-arg>
<map>
<entry key="javax.persistence.jdbc.url"
value="jdbc:postgres://${OPENSHIFT_POSTGRESQL_DB_HOST}:${OPENSHIFT_POSTGRESQL_DB_PORT}/db"/>
<entry key="javax.persistence.jdbc.user"
value="${OPENSHIFT_POSTGRESQL_DB_USERNAME}"/>
<entry key="javax.persistence.jdbc.password"
value="${OPENSHIFT_POSTGRESQL_DB_PASSWORD}"/>
</map>
</constructor-arg>
</bean>
denn auch hier gibt es entsprechende Parameter beim Erzeugen in diesem Fall der EntityManagerFactory:
factory =
Persistence.createEntityManagerFactory(persistenceUnitName,
jpaConfigOverrides);
Cloudbees
Über die Vorgehensweise hier stolperte ich erst, als ich meine Anwendungen mit Tangram auf OpenShift betreiben wollte, nachdem sie bei cloudbees schon liefen, da es für MySQL auf run@cloudbees eine "managed" Lösung mit einer DataSource gibt<!-- jndi datasource example (run@cloudbees) -->
<property name="datanucleus.ConnectionFactoryName"
value="java:comp/env/jdbc/mydb" />
Das Problem besteht also mit der "hauseigenen" MySQL Datenbank dort überhaupt nicht.
Aber auch in dieser Umgebung werden ganz allgemein Werte der Betriebsumgebung an die Anwendungen durchgereicht und sollten von dieser auch benutzt werden.
URL Splitting in der Spring-Konfiguration
Das geht leider nicht ganz genau wie oben beschrieben, da unter Cloudbees z.B. für MongoDB die Verbindungdaten in einer URL übergeben werden (die gibt es auf OpenShift auch, aber man kann dort auch direkt auf die Einzelteile zurückgreifen).Die Lösung ist hier mit ein wenig Programmieraufwand (s.o.) verbunden, da ich mich entschlossen habe, die Property-Ersetzungen durch Spring an dieser Stelle ein wenig aufzubohren und ganz allgemein URLs in ihren Teilen nutzbar zu machen.
Den
<bean id="propertyConfigurer"
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<list>
<value>classpath*:/tangram/*.properties</value>
<value>/WEB-INF/tangram/*.properties</value>
</list>
</property>
</bean>
ersetze ich also durch einen eigenen
<bean id="propertyConfigurer"
class="org.tangram.spring.PropertySplittingPlaceholderConfigurer">
<property name="locations">
<list>
<value>classpath*:/tangram/*.properties</value>
<value>/WEB-INF/tangram/*.properties</value>
</list>
</property>
</bean>
Danach steht von jeder URL, wie z.B. ${MONGOHQ_URL_MYBD} für den Service MongoHQ auf Cloudbees mit der verbundenen Datenbank MYDB, die Teile zur Verfügung:
<bean id="jdoConfigOverrides" class="java.util.HashMap">
<constructor-arg>
<map>
<entry key="javax.jdo.option.ConnectionURL"
value="mongodb:${MONGOHQ_URL_TANGRAM.host}:${MONGOHQ_URL_MYBD.port}/${MONGOHQ_URL_MYDB.uri}" />
<entry key="javax.jdo.option.ConnectionUserName"
value="${MONGOHQ_URL_MYDB.username}" />
<entry key="javax.jdo.option.ConnectionPassword"
value="${MONGOHQ_URL_MYBD.password}" />
</map>
</constructor-arg>
</bean>
Das macht die Implementierung für alles, was sie für eine URL hält, und damit wird sie zu einem recht universellen Werkzeug bei der Spring-Konfiguration.
Jede URL in einer Property-Datei
# Example
url=mongodb://ruth:guessme@mongo.host:8111/db
wird zerlegt in
url.username=ruth
url.password=guessme
url.host=mongo.host
url.port=8111
url.uri=db
Diese Platzhalter fügt der PlaceholderConfigurer dann an allen gewünschten Stellen ein. Das sollte für einen ganzen Bereich von Anwendungen erst einmal mit einem Werkzeug ausreichen.
English (sort of) Summary
For easier parameter passing through the springframework down into the JDO or JPA persistence layers of you app - especially on the plattforms of CloudBees and OpenShift - I introduced a PropertySplittingPlaceholderConfigurer, which splits everything it consideres a URL into the parts host, port, username, password, protocol, and uri.So anything in the form of
# Example
url=mongodb://ruth:guessme@mongo.host:8111/db
gets exploded as if it would read
url.protocol=mongo
url.username=ruth
url.password=guessme
url.host=mongo.host
url.port=8111
url.uri=db
These generated properties can subsequently be used as placeholders in your springframework XML configuration files. So, what started as a little helper to connect to the databases of OpenShift in the best practice way, ended as a small but universal helper class.
