# Einsatz von Spring zusammen mit klassischem MVC + Swing



## Boiorix (19. Jul 2011)

Hallo zusammen!

Wir wollen bei einer bestehenden Desktop-Application, welche anhand des MVC-Pattern und Swing entwickelt wurde, Spring einsetzen um View, Model und Controller über die Spring-XML-Konfiguration austauschbar zu machen.
Allerdings bekomme ich da Probleme mit "Circular References", da der Controller ja die View kennt und die View den Controller (als Interface), und das scheint Spring gar nicht zu mögen.

Sollte man Spring für ein solches Szenarion überhaupt verwenden?


----------



## Boiorix (22. Jul 2011)

Ich habe das MVC jetzt so abgeändert, dass es für unsere Zwecke passt. Allerdings glaube ich dass sich hier ein MVP am besten machen würde. Durch die "Circular References" ist ein klassisches MVC mit Spring, meiner Meinung nach, einfach nicht in Einklang zu bringen.


----------



## maki (22. Jul 2011)

"Circular References" sind kein Markenzeichen von "klassischem MVC", sondern das Markenzeichen eines klassischen Designfehlers...


----------



## Boiorix (22. Jul 2011)

maki hat gesagt.:


> "Circular References" sind kein Markenzeichen von "klassischem MVC", sondern das Markenzeichen eines klassischen Designfehlers...



Ich glaube eher dass "Circular References" ein Problem von Spring im Zusammenhang mit "klassischem MVC" sind, denn:


```
public class Controller implements IController{

  private IView view;
  private IModel model;

  public Controller(IView view, IModel model){
    this.view = view;
    this.model = model;
    ((Observable)model).addObserver(view);
  }

  public void userInput(String input){
    model.loadFromDatabase(input);
  }

...
}
```


```
public class View extends JPanel implements IView, Observer{

  private IController controller;

  public View(IController controller){
    this.controller = controller;
  }

  public void update(Observable o, Object arg) {
    ...
  }

}
  ...
}
```


```
public class Model extends Observable implements IModel{

  public Model(){
    
  }

  public loadFromDataBase(String name){
    ...
    changed();
    notifyObservers();
  }

}
```

Das ist, was ich unter der klassischen Struktur eines MVC's verstehe.
Und wenn ich jetzt mit Spring eine Context hierfür erstelle, würde die so aussehen:

[XML]
...
<bean id="controller" class="de.test.Controller" />
  <constructor-arg ref="model" />
  <constructor-arg ref="view" />
</bean>

<bean id="view" class="de.test.View" />
  <constructor-arg ref="controller" />
</bean>

<bean id="model" class="de.test.Model">
...
[/XML]

Solch ein Konstrukt ergibt eine "Circular Reference" in Spring. (Habe das Beispiel jetzt nicht getestet, da es von mir jetzt einfach nur hingehackt worden ist).


----------



## maki (22. Jul 2011)

> Ich glaube eher dass "Circular References" ein Problem von Spring im Zusammenhang mit "klassischem MVC" sind


Musste jetzt nochmal nachsehen was Sun/ORacle genau mit "classical MVC" meinten (es gibt wohl mehr MVC Interpretationen als Implementierungen  haben hier regelmässig Diskussionen deswegen), solange die Abhängigkeiten von konkreten Klassen nur aus Interfaces bestehen, sollte es ja keine zirk. Abhängigkeiten zwischen Implementierungen geben, oder stehe ich gerade auf dem Schlauch?


----------



## Boiorix (22. Jul 2011)

Innerhalb von Spring müssen konkrete Beans oder Klassen angegeben werden(?), und da nutzen ja leider dann auch keine Interfaces. Und da hier eine Bean die andere referenziert, versucht Spring Bean A zu instanzieren, sieht aber dass es dazu b braucht. B wiederum braucht aber A und genau damit kann Spring wohl nicht umgehen!?

Da ich kein Spring-Experte bin, weiss ich jetzt nicht 100%ig ob meine Aussage hier stimmt.


----------



## maki (22. Jul 2011)

IME gibt es eine Möglichkeit das Spring damit klarkommt, Setterinjection anstatt Constructorinjection, damit können die Objekte nämlich erzeugt werden, danach konfiguriert/injiziert.


----------

