Is there a collection of commonly-agreed-upon design guidelines for separating the Model classes from the View/Controller classes in a Java Swing app? I'm not so concerned that the View/Controller know nothing about the Model as the other way around: I'd like to design my Model to have no knowledge of anything in javax.swing. Ideally it should have a simple API enabling it to be driven by something as primitive as a CLI. It should be, loosely speaking, an "engine."
Communicating GUI events to the model isn't too hard — the Action Performers can call the model's API. But what about when the model makes its own state changes that need to be reflected back to the GUI? That's what "listening" is for, but even "being listened to" is not entirely passive; it requires that the model know about adding a listener.
The particular problem that got me thinking involves a queue of Files. On the GUI side there's a DefaultListModel
behind a JList
, and there's some GUI stuff to choose files from the file system and add them to the JList. On the Model side, it wants to pull the files off the bottom of this "queue" (causing them to disappear from the JList) and process them in some way. In fact, the Model code is already written — it currently maintains an ArrayList<File>
and exposes a public add(File)
method. But I'm at a loss as to how to get my Model working with the View/Controller without some heavy, Swing-specific modifications to the Model.
I'm very new to both Java and GUI programming, having always done "batch" and "back-end" programming up to now — hence my interest in maintaining a strict division between model and UI, if it's possible and if it can be taught.
Best Answer
There are no commonly-agreed-upon (i.e. defacto) design guidelines for MVC. It is not that entirely hard to do it yourself but requires some planning on your classes and lots of time and patience.
The reason there is no definite solution is because there are multiple ways to do MVC, all with their pros and cons. So just be smart about it and do what suits you the best.
To answer your question, you actually want to decouple the controller from the view as well (so you can use the same business rule logic for both a Swing app and in the console app). In the Swing example you want to decouple the controller from the
JWindow
and whatever widget in Swing. The way I used to do (before using actual frameworks) is to create an interface for the view that the controller uses:For this solution during startup you need to register the controller into the view.
It might be a good idea to create an IoC-container to do all the setup for you instead.
Anyhow, this way you can implement console-only views, using the same controllers:
The fun part is how to do event handling. I implemented this by letting the view register itself to the controller using an interface, this is done using the Observer pattern (if you're using .NET you'd be using event handlers instead). Here is an example of a simple "document observer", that signals when the a document has been saved or loaded.
That way, the view can properly update itself since it is subscribing to the document updates. All it has to do is to implement the
DocumentObserver
interface:I hope these motivating examples gives you some ideas on how to do it yourself. However I strongly advise you to consider using frameworks in Java that do most of the things for you, or else you'll end up having a lot of boilerplate code that takes a long time to write. There are a couple of Rich Client Platforms (RCP) that you could use that implement some of the basic functionality that you most likely need, such as application-wide document handling and a lot of basic event handling.
There are a couple I can think of from my head: Eclipse and Netbeans RCP's.
You still need to develop controllers and models for yourself, but that's why you use an ORM. Example would be Hibernate.
IoC containers are cool'n all, but there are frameworks for this as well. Such as Spring (which also does data handling as well among other things).