Java Swing Design Guide

Question

I have written an application that is using Swing for the GUI, accepts a file via the GUI, parses the Input, saves it in DataList and sends it to a server. I'm concerned about the whole design of my program, which I don't think is very good. I'm using Netbeans to design the GUI and have a class MainClass that starts that GUI and has a static reference to the GUI. Also there are a couple of ExecClasses that do the aforementioned parsing and sending of the data.

                 +----------------------+
                 | MainClass (static)   |
                 |----------------------|
          +------+  -DataList           +-----+
          |      |                      |     |
    static|      +-+--------------+-----+     |static
  reference        |              |           |reference
          |        |new ()        | new ()    |
          |        |              |           |
          |        |              |           |
        +-+--------v----+      +--v-----------+--+
        |               |      |                 |
        | SwingGUIClass |      | ExecClasses     |
        |               |      |                 |
        +--/\-----------+      +-----------------+
           |
          Input file

Here a short overview of the MainClass :

public class MainClass {

    private static MainClass mainClass;
    private static ExecClass1 ex1;
    private static ExecClass2 ex2;
    private static ExecClass3 ex3;

  public static void startExecClass2(String param){

     ex2 = new ExecClass2(param);
  }

I'm using these references so that the SwingGUIClass can execute a method in the ExecClass1 for example. I chose this approach since I have a TextArea that needs to get the data out of one of the ExecClasses and display it in the GUI. Since I can't modify the TextArea from the ExecClass.

public class SwingGUIClass {

  [...]
  private void ButtonActionPerformed(java.awt.event.ActionEvent evt) { 

  Label.setText(MainClass.getList());
}
  private void Button2ActionPerformed(java.awt.event.ActionEvent evt) { 

   MainClass.startExecClass2(Button2.getText());
}

I understand that this is a far from great design and not following a couple of good practice guides, e.g. MVC. So my question is : How would you design this and which general pointers can you give me?

Answer 1

First of all, don't do logic based on static references on things, that you can use in multiple context. For example in future, you can have a requirement to have several windows of your GUI interfaces interacting with several instances of your services.

Also you are killing testability.

Treat GUI and application logic separately - don't think in your application logic (exec classes) about GUI text field etc. Just think about input and output, and provide a class to communicate each other (the controller). You can provide data to application logic in controller, get results and display it in GUI like:

public void processFile( SomeInputFromGui input ) {
 SomeResult result = applicationLogicObject.process( input );
 guiObject.showResult( result );
}

Your components should be loose coupled, so you can reuse and test them. You can achieve that with simple dependency injection like putting your dependencies in contructors/setters:

public void initApplication() {
  AppLogic logic = new AppLogic();
  AppWindow window = new AppWindow();
  AppController controller = new Controller( logic , window );
}

This is very simple draft of controller initializning method. With that, you can test/reuse your logic or your GUI in other places like unit tests.

To move bussiness logic from your window, where all events are fired (buttons etc.) you can create a interface, which will work with your window:

public interface ProcessingController {
public void processFile( File x );
public void checkIntegrity();
public SomeDataValues getCurrentDataValues();
}

And you can implement this logic in your controler (implements) and use it as GUI events receiver:

window.setProcessingController( controller );

...

private void ButtonActionPerformed(java.awt.event.ActionEvent evt) { 
   processingController.processText( jMyTextField.getText() );
}

And now you have two-way communication with window and controller.

Those are basic points, that gives you testability and ability to make as much logic/controller/windows as you want. Also you have loose coupled components: you can inject a almost-empty stub of AppLogic for test purposes or faked AppWindow to simulate user acions in test. Of course to subsitute components, you should extract interfeces and provide specific implementations:

SwingAppWindow implements ApplicationUserInterface { ...
SQLDataManager implements ApplicationDataLogic { ...
BasicController implements ProcessingController { ...

Of course you can split it even further to separate data access and bussines logic.

And remeber that all your gui actions (events, updates) should run in swing event thread, so you should use SwingUtils, beacuse swing is not thread safe:

SwingUtilities.invokeLater(new Runnable() {
    public void run() {
      .... queued action that changes the gui ...
    }
  });

Remeber to not hard-code object instantation with new in your logic classes, for example don't make new Window and new ApplicationDataModel in your controller - because you can't test your controller independly or reuse it with different logic/window implementation - you can create some class only to prepare your application dependencies (create components and link them) and "start it" - it's generally called a factory.

If your logic will grown and become more complicated, split it into more service objects and you can use a command pattern to produce commands in your gui and process it (for example in thread safe queue) in application services - which also will be good starting point to undo/redo ability.

Last one thing - if you have any long running processing task (even if it took 1 second we can say that it's long running), remeber that invoking it directly or in swingUtils will freeze your gui, so for lenghty operations create separate threads with a Thread, Executors, Runnable, SwingWorker or something (you can use a observer pattern to monitor progress etc).

Have in mind that this is really a big topic and this post mention only some small general advices.

The "other road" to take can be to use a already provided architecture to create GUI application like Eclipse RCP or Netbeans Platform.