Relationship Manager Pattern vs. ORM

[s.h.a.r.k]

Heyho,

bin gerade mal wieder dabei ein eigenes ORM zu basteln bzw. mich dies bzgl schlau zu machen, da ich evtl. gar kein eigenes brauche und auf andere zurückgreifen kann. Allerdings spielt hier ein gewisses Problem rein, mit welchem ich immer noch irgendwie Problemchen habe: Beziehungen zwischen Objekten (1:1, 1:n, n:m). Ich habe immer wieder darüber nachgedacht, wie ein ORM sowas sinnvoll handelt kann bzw. ob ich meine Klassen an ein ORM anpassen muss, was ja eigentlich nicht so dolle ist, wie ich finde.

Jedenfalls bin ich in diesem Zusammenhang über dieses Paper gestolpert. Es geht im Allgemeinen darum, dass eine Klasse nicht direkt eine andere Referenziert, um eine Beziehung herstellen, sondern übergibt diese "Funktionalität" und die Verwaltung einem RelationshipManager. Die Klasse selbst stellt dann nur noch entsprechende Schnittstellen bereit, über die alle Beziehungen abgerufen werden können. Alles rund um die Beziehung managt somit der Relationship Manager -- zumindest habe ich es so verstanden ;)

Die Idee selbst gefällt mir ungemein, da ich so viel leichter mit einem Third-Party-ORM klar kommen würde, denn ein ORM ist ja nicht unbedingt für Abbildungen von Beziehungen gedacht, vor allem machen ja n:m Beziehungen doch Probleme.

Was mich aber im Grunde sehr wundert ist, dass ich bisher nichts vergleichbares hier gefunden habe. Und daraus resultiert die Frage, wie ihr sowas handhabt?! Gibt es neuere/bessere Methoden?

[mjustin]

Aktuelle Persistenzstandards wie z.B. JPA gehen sehr direkt mit Relationen um, es werden einfach Annotationen (in Delphi als Attribute bekannt) benutzt mit denen das ORM die Zusammenhänge erfährt.

Der Entwickler arbeitet also mit den gewohnten Listen von Objekten, die vom Persistenzframework gefüllt werden.

N : M ist kein Problem, dazu wird bei JPA die ManyToMany Assosziation verwendet:

Code:

@IdClass(RoutePlacePK.class)
@Entity
public class RoutePlace {
    private Collection<RoutePlace> route;

    @ManyToMany(mappedBy = "place")
    public Collection<RoutePlace> getRoute() {
        return route;
    }

    public void setRoute(Collection<RoutePlace> route) {
        this.route = route;
    }

    private Collection<RoutePlace> place;

    @ManyToMany
    public Collection<RoutePlace> getPlace() {
        return place;
    }

    public void setPlace(Collection<RoutePlace> place) {
        this.place = place;
    }
}

http://stackoverflow.com/questions/1...ey-with-itself

Ich arbeite noch nicht viel mit JPA, es ist aber in der Praxis weit verbreitet, unter der Haube arbeitet dann Hibernate oder ein anderes etabliertes Framework. JPA standardisiert 'nur' die Spezifikation.