Ein schönes (bzw. ärgerliches) Beispiel für eine solche Situation stellen die NamedQueries von JPA dar. Man darf heute Annotations schreiben statt XML, aber eine Refactoring-Unterstützung durch den Compiler ist immer noch nicht gegeben. Nehmen wir mal folgende Entity:
@NamedQueries({
@NamedQuery(name="selectAll",
query="select e from Employee e"),
@NamedQuery(name="selectNames",
query="select e.name from Employee e")
})
@Entity
public class Employee { ... }
Das Problem liegt offensichtlich darin, dass wir keinerlei Compiler-Unterstützung hinsichtlich der Query-Namen erwarten können:
em.createNamedQuery("selectQll");
... ergibt keine Compiletime-Fehlermeldung. Noch dazu: Die Bezeichnung "selectAll" liegt in einem globalen Namespace. Wir müssen also überhaupt erst die Entity finden, bei der die NamedQuery definiert ist. Man nennt die Query also vielleicht besser "employee.selectAll". Dann sollte man allerdings nicht vergessen, das per Hand zu ändern, falls die Klasse Employee irgendwann umbenannt wird. Oh je.
Aus meiner Sicht hätte es hier eine Reihe von Möglichkeiten gegeben, den Compiler einzuspannen. Zum Beispiel so:
public enum EmployeeQueries {
/** Selects all employees */
@EnumQuery(query="select e from Employee e")
SELECT_ALL,
SELECT_ALL,
/** Selects the names of all employees */
@EnumQuery(query="select e.name from Employee e")
SELECT_NAMES
SELECT_NAMES
};
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public abstract @interface EnumQuery {
public abstract String query();
...
};
Die enum "EmployeeQueries" darf hierbei eine Top-Level-Klasse sein, oder auch innerhalb einer Entity definiert werden.
Vorteile wären:
- Compiletime-Überprüfung
- Automatisches Refactoring
- Automatische Ergänzung (z. B. in Eclipse nach Eintippen von "EmployeeQueries." Damit erhält man erstens eine Auflistung der verfügbaren Queries, und zweitens eine direkte Einblendung der Javadoc pro Query.)
Ich persönlich glaube, dass solche Tool-Unterstützung nicht nur die Produktivität erhöht, sondern vor allen Dingen die Fehlerwahrscheinlichkeit deutlich senkt. Dazu muss man einmal die Anzahl der Schritte vergleichen, die ein Entwickler in beiden Fällen durchführen muss:
- JPA NamedQueries:
- createNamedQuery() schreiben
- Entity-Klasse suchen
- Query in der Entity-Klasse suchen
- Javadoc zur Query suchen (falls es überhaupt eine gibt - denn die Queries sind schließlich keine Java-Elemente, sondern nur als Annotations vorhanden - also falls ja, dann befindet sie sich wohl irgendwo in der Javadoc für die gesamte Entity-Klasse)
- Zurück zur richtigen Query
- Namensattribut kopieren
- Zurück zu createNamedQuery(...) (wo war das jetzt nochmal?)
- Namen einfügen
- Mit dem weitermachen, was man sich überlegt hatte
- EnumQuery (oder ähnliche Lösungen):
- createNamedQuery() schreiben
- Mit den Pfeiltasten eine Query selektieren, dabei Javadoc direkt ablesen
- Weitermachen
Es könnte so schön sein (und es wär doch gar nicht soo schwierig gewesen, oder?)
