Swing patterns

After reading the series of posts from Gregg Bolinger about Swing best practices, I thought I should share some of the patterns I use when writing Swing applications. I was going to post this as a comment in the original post, but it was too long so I'm writing a post instead ...


Usually we have only one main frame in a typical Swing application, so I implement this as a singleton named MainFrame :


public class MainFrame extends JFrame {

private static MainFrame INSTANCE;

public static MainFrame getInstance() {
if (INSTANCE == null)
INSTANCE = new MainFrame();

return INSTANCE;
}

private MainFrame() {
// ...
}

}


Each components in the frame has an accessor, where it is lazily loaded. For example :


private JPanel footer;
private JList menu;

public JPanel getFooter() {
if (footer == null) {
footer = new JPanel();
// ...
}

return footer;
}

public JList getMenu() {
if (menu == null) {
menu = new JList();
// ...
}

return menu;
}


So if somewhere in the application I have to do some stuff on a component all I have to do is :


MainFrame.getInstance().getMyComponent().doSomeStuff();


These components are added to the frame inside the constructor :


private MainFrame() {
// ...

this.add(getFooter());

// ...
}


If the various listeners are too complex to be created using an anonymous class, I use a private inner class named InnerListener :


private class InnerListener extends MouseAdapter implements MouseMotionListener, WindowListener {

public void mouseClicked(MouseEvent e) {
// ...
}

// ...

}


which is registered inside the constructor :


private InnerListener innerListener;

private MainFrame() {
// ...

innerListener = new InnerListener();
this.getFooter().addMouseListener(innerListener);

// ...
}


The idea here is to keep the various methods from the listeners interface private. See this example from my "fake app" :

before, no inner class

after, using a private inner class

The public API of the main frame is clean, no useless methods are accessible. Of course you can create multiple inner listeners if there is a lot of  code, for example MouseInnerListener and WindowInnerListener ...

The problem with these patterns is that the MainFrame class can become quite big (878 lines in my fake app, and still growing).

The complete skeleton for the MainFrame class :


public class MainFrame extends JFrame {


private static MainFrame INSTANCE;


private JPanel footer;

private JList menu;

private InnerListener innerListener;



public static MainFrame getInstance() {

if (INSTANCE == null)

INSTANCE = new MainFrame();



return INSTANCE;

}



private MainFrame() {

// ...


this.add(getFooter());


// ...


innerListener = new InnerListener();

this.getFooter().addMouseListener(innerListener);


// ...

}



public JPanel getFooter() {

if (footer == null) {

footer = new JPanel();

// ...

}


return footer;

}


public JList getMenu() {

if (menu == null) {

menu = new JList();

// ...

}



return menu;

}



private class InnerListener extends MouseAdapter implements MouseMotionListener, WindowListener {


public void mouseClicked(MouseEvent e) {

// ...

}



// ...



}


}


Of courses these are not "official" rules, just some practices I have found over the time, so I'd really like some feedback :)