[Java] MVC voorbeelden gezocht

[Verwijderd]

Heeft iemand misschien MVC voorbeelden voor Java? Het enige wat ik kan vinden zijn (delen) van applets.

Ik had graag een werkend progsel in Java dat volgens het MVC model werkt.

(MVC = Model View Control)

[Alarmnummer]

http://forum.javahova.net/topic.php?id=526

en dan moet je even mijn reply opzoeken.

[Kwistnix]

Even een oude koe uit de sloot halen.
Ik weet wat MVC is en hoe je het kan implementeren in Java.
Waar ik echter tegenaan loop, is het verschil in implementatie.
Iedereen pakt het op een andere manier aan. Ik vraag me af wat de handigste / beste (als je daar van kan spreken) manier van implementeren is.
Hier twee voorbeelden (naast de link in bovenstaande reply):

http://csis.pace.edu/~bergin/mvc/mvcgui.html

http://student-nt.wou.edu/morses/MVC/index.htm

Zoek de verschillen
Welke implementatie zouden jullie gebruiken?

[ Voor 3% gewijzigd door Kwistnix op 02-09-2004 00:04 ]

[MisterData]

Kijk naar Swing, daar zit een hoop MVC in. Vooral bij dingen als lijsten, waar je vaak een model hebt en een view in de vorm van 2 aparte classes Ik kan me de namen niet meer herinneren maar het zou zo te vinden moeten zijn

[bigbeng]

[purist-modus]
MVC = Model View Controller
[/purist-modus]

[Macros]

Het is me opgevallen van mezelf, dat als ik zelf components schrijf dat die vaak geen gebruik maken van MVC. Maar als de applicatie groeit, dan word ik gedwongen om uiteindelijk toch de MVC structuur er uit te refactoren.

[Antediluvian]

Dit vind ik een mooie implementatie van MCV adhv Sevlets/Beans/JSP

http://www.stardeveloper....article=2001060501&page=1

er zijn trouwens nog tal van intressante dingen te vinden op die site.

[Verwijderd]

Antediluvian schreef op 02 september 2004 @ 01:54:
Dit vind ik een mooie implementatie van MCV adhv Sevlets/Beans/JSP

http://www.stardeveloper....article=2001060501&page=1

er zijn trouwens nog tal van intressante dingen te vinden op die site.

Niet geheel ontopic maar wel interessant: 2 articles waarin geopperd wordt dat MVC voor web applicaties zwaar overhyped en niet ideaal is ( doh ).

http://today.java.net/pub/a/today/2003/12/11/mvc.html

En deze ook wel geinig als je nog steeds niet overtuigd bent
http://www.nooranch.com/s...i.cgi?ModelViewController

Komt er eigenlijk op neer dat je moet beseffen dat MVC niet de holy grail is. MVC is slechts een handigheidje dat je gebruikt op de plek waar het nuttig is. MVC is dus zeker wel toepasbaar in web applicaties maar slechts in de human interaction layer (UI).

[ Voor 47% gewijzigd door Verwijderd op 02-09-2004 11:15 ]

[djengizz]

Bekijk de voorbeelden uit de Java BluePrints eens:
http://java.sun.com/blueprints/patterns/MVC-detailed.html
Hier wordt verwezen naar 3 verschillende toepassingen van MVC:

The Java Pet Store (webapp met JSP's (V), Servlet (C) en EJB's (M))
FrontController Pattern (Gecentralizeerde Controller)
Smart Ticker app (Applicatie voor mobiele (telefoon, etc) client)

Het is wel allemaal erg j2ee maar in ieder geval geen delen van applets

[Alarmnummer]

djengizz schreef op 02 september 2004 @ 20:39:
Het is wel allemaal erg j2ee maar in ieder geval geen delen van applets

Wat is er mis met normale GUI`s? Swing is erg prettig in elkaar gezet op basis van MVC (het meeste).

[djengizz]

Alarmnummer schreef op 02 september 2004 @ 20:55:
Wat is er mis met normale GUI`s? Swing is erg prettig in elkaar gezet op basis van MVC (het meeste).

Er is niets mis met normale GUI's. Ik geef alleen aan dat deze voorbeelden niet onder dat hoofdstuk vallen.

[Verwijderd]

Wat is er mis met normale GUI`s? Swing is erg prettig in elkaar gezet op basis van MVC (het meeste).

Probleem met Swing is wel dat het Model gedeelte af en toe wat te ver gezocht is, of zo overdreven is dat het een hoop extra werkt met zich mee brengt als je het fatosenlijk wilt gebruiken. In principe zit het dan wel goed in elkaar, maar dat is (in mijn geval dan ) vaak twijfelachtig door de slechte documentatie van de API... Het hele Document / EditorKit / JTextComponent verhaal heeft me al de nodige problemen bezorgd, om maar eens een voorbeeld te noemen.

En het Controller deel is in Swing vaak 'verwerkt in het View gedeelte' bij interactieve componenten. Als je bijvoolbeeld aan een JSlider schuift dan wordt het model en de view meteen geupdate. Ook als je het Model van de slider aanpast, zal deze meteen z'n view aanpassen. Waar is de controller??

Nou zijn bovenstaande problemen misschien niet wereldschokkend, maar dat ze dan niet de indruk wekken dat Swing het schoolvoorbeeld is van een MVC GUI implementatie.


[on-topic ]

Op JavaHova (sorry Alarmnummer ) zijn inderdaad een aantal puristen discussies te vinden over MVC en andere interessant design patterns over hun voor- en nadelen en hoe ze het beste geimplementeerd kunnen worden.

[Verwijderd]

Uit mijn post in dit topic [rml][ Jsp/Servlets]RequestDispatcher[/rml]

MVC (Model View Controller) draait juist om het feit dat je presentatie (jsp) en logica (Model) van elkaar scheidt. Hierbij draait alles om de combinatie van de controller (servlet), een action Interface, een Map (HashMap) en uiteindelijk de action classes die de action interface implementeren.

Onder de motorkap gebeurt dan het volgende:
request (in querystring action=foobar > servlet > match action ("foobar" met een entry "foobar" in de Map > voor de action uit (databse query's etc) > forward naar jsp. In feite voert de controller alle operaties uit.

Voorbeeld:

De Controller (servlet)

Java:

public class Controller extends HttpServlet {
  private static final String CONTENT_TYPE = "text/html";
  private ActionMapping mapping;
  private HttpServletRequest request;
  private HttpServletResponse response;

  public void init() throws ServletException {
    mapping = new ActionMapping();
  }

  public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
     this.request = request;
     this.response = response;

     Action a = mapping.findAction(getActionName()); // hier de corresponderende class instantieren (getActioName haalt de action uit de querystring)

     String path = a.perform(request, response); // methode perform uitvoeren (omdat alle *Action classes de interface implementeren, weet je dat ze allemaal deze methode MOETEN bevatten!)

     forward(path); // forwarden naar view (jsp)
   }

   protected String getActionName(){
     String action = request.getParameter("action");
     if ((action==null) || (action.equals(""))) action="Index";
     return action;
   }

   protected void forward(String path)
       throws ServletException, IOException {
     RequestDispatcher disp = request.getRequestDispatcher(path);
     disp.forward(request, response);
   }

  //Clean up resources
  public void destroy() {
  }
}

De Action Interface:

Java:

public interface Action {

  public String perform(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException;

}

De ActionMapper:

Java:

public class ActionMapping {
  private HashMap actionMap;

  public ActionMapping() {
    actionMap = new HashMap();
    actionMap.put("foobar", new FoobarAction());
  }

  public Action findAction(String actionName){
    return (Action) actionMap.get(actionName);
  }
}

En dan zien de logica classes er ongeveer als volgt uit:

Java:

public class FoobarAction implements Action {
  public FoobarAction () {
  }

  public String perform(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    // Eventuele variabelen ophalen uit querystring of form
    // Query's uitvoeren
    
    request.setAttribute("resultaat", "De informatie die getoond moet worden komt hier (bijv array)"); // in jsp vervolgens request.getAttribute("resultaat") om de info weer te geven
    return "foobar.jsp"; // methode forward in de controller forward naar deze pagina
  }

}

Ik hoop dat je hier wat wijzer van wordt. Dit heb ik het vaak gebruikt als het om een "lichgewicht" mvc implementatie ging. Als je het gaat gebruiken, hou er dan wel even rekening mee dat de packages en imports gemakshalve zijn weggelaten. De werking is honderd procent gegarandeert en het is een heuze implementatie van het MVC design pattern.

p.s. sorry voor het ontbreken van commentaar in de code, maar daar ben ik nu even te lui voor

Struts werken grofweg eigenlijk hetzelfde, echter configureer je de boel via xml bestanden. Als je daadwerkelijk volgens een design pattern als het MVC in Java gaat ontwikkelen, kijk dan eens naar deze implementatie en de struts implementatie. Over het algemeen is dit het makkelijkst "aanleerbaar"