public class ApplicationInstanceManager {

    private static ApplicationInstanceListener subListener;

    /** Randomly chosen, but static, high socket number */
    public static final int SINGLE_INSTANCE_NETWORK_SOCKET = 44331;

    /** Must end with newline */
    public static final String SINGLE_INSTANCE_SHARED_KEY = "$$NewInstance$$\n";

    /**
     * Registers this instance of the application.
     *
     * @return true if first instance, false if not.
     */
    public static boolean registerInstance() {
        // returnValueOnError should be true if lenient (allows app to run on network error) or false if strict.
        boolean returnValueOnError = true;
        // try to open network socket
        // if success, listen to socket for new instance message, return true
        // if unable to open, connect to existing and send new instance message, return false
        try {
            final ServerSocket socket = new ServerSocket(SINGLE_INSTANCE_NETWORK_SOCKET, 10, InetAddress
                    .getLocalHost());
            log.debug("Listening for application instances on socket " + SINGLE_INSTANCE_NETWORK_SOCKET);
            Thread instanceListenerThread = new Thread(new Runnable() {
                public void run() {
                    boolean socketClosed = false;
                    while (!socketClosed) {
                        if (socket.isClosed()) {
                            socketClosed = true;
                        } else {
                            try {
                                Socket client = socket.accept();
                                BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));
                                String message = in.readLine();
                                if (SINGLE_INSTANCE_SHARED_KEY.trim().equals(message.trim())) {
                                    log.debug("Shared key matched - new application instance found");
                                    fireNewInstance();
                                }
                                in.close();
                                client.close();
                            } catch (IOException e) {
                                socketClosed = true;
                            }
                        }
                    }
                }
            });
            instanceListenerThread.start();
            // listen
        } catch (UnknownHostException e) {
            log.error(e.getMessage(), e);
            return returnValueOnError;
        } catch (IOException e) {
            log.debug("Port is already taken.  Notifying first instance.");
            try {
                Socket clientSocket = new Socket(InetAddress.getLocalHost(), SINGLE_INSTANCE_NETWORK_SOCKET);
                OutputStream out = clientSocket.getOutputStream();
                out.write(SINGLE_INSTANCE_SHARED_KEY.getBytes());
                out.close();
                clientSocket.close();
                log.debug("Successfully notified first instance.");
                return false;
            } catch (UnknownHostException e1) {
                log.error(e.getMessage(), e);
                return returnValueOnError;
            } catch (IOException e1) {
                log.error("Error connecting to local port for single instance notification");
                log.error(e1.getMessage(), e1);
                return returnValueOnError;
            }

        }
        return true;
    }

    public static void setApplicationInstanceListener(ApplicationInstanceListener listener) {
        subListener = listener;
    }
}

public interface ApplicationInstanceListener {
    public void newInstanceCreated();
}

public class MyApplication {
    public static void main(String[] args) {
       if (!ApplicationInstanceManager.registerInstance()) {
                    // instance already running.
                    System.out.println("Another instance of this application is already running.  Exiting.");
                    System.exit(0);
       }
       ApplicationInstanceManager.setApplicationInstanceListener(new ApplicationInstanceListener() {
          public void newInstanceCreated() {
             System.out.println("New instance detected...");
             // this is where your handler code goes...
          }
       });
    }
}

public class MyClass extends MyBaseClass {

    public void doStuff() {
       System.out.println("Watch me invoke the command");
       File chosenFile = executeCommand(Command.CHOOSE_FILE, new ChooseFileCommandParameters("c:\", "*.txt"));
       System.out.println("The file you chose is: " + chosenFile);
    }
}

/** the command class defines the interface for a command and has the available commands listed out in my
* implementation.  The important thing is the interface itself but the Command constants can be located in any
* class or classes.
*/
public class Command<ParamType, ReturnType> {
    public static final Command<ChooseFileCommandParams, File> CHOOSE_FILE = new Command<ChooseFileCommandParams, File>(
            "Choose File");

    public static final Command<AnotherCommandParams, String> ANOTHER_COMMAND = new Command<AnotherCommandParams, String>(
            "Another Command");

    private String name;

    private Command(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

/**
* This is the interface for handling the commands that are executed.  Implement this using the correct parameter
* type and return type to have code that handles the command.
*/
public interface CommandHandler<ParamType, ReturnType> {
    public ReturnType execute(ParamType params) throws Exception;
}

/**
 * Used to Bind Commands to CommandHandlers with parameterized types
 *
 * The point of this class is to enforce the 1-1 relationship between a command's param/return types and the handler's
 * param/return types
 *
 */
public class CommandHandlerBinding<ParamType, ReturnType> {
    private Command<ParamType, ReturnType> command;

    private CommandHandler<ParamType, ReturnType> handler;

    public CommandHandlerBinding(Command<ParamType, ReturnType> command, CommandHandler<ParamType, ReturnType> handler) {
        this.command = command;
        this.handler = handler;
    }

    public Command<ParamType, ReturnType> getCommand() {
        return command;
    }

    public CommandHandler<ParamType, ReturnType> getHandler() {
        return handler;
    }
}

/**
* base class - I don't do anything with it but I'm sure people would.
*/
public abstract class CommandParameters {
}

/**
* Parameters for the file chooser command
*/
public class ChooseFileCommandParameters extends CommandParameters {
    private String path;

    private String filter;

    public ChooseFileCommandParameters (String path, String filter) {
        this.path = path;
        this.filter = filter;
    }

    public String getPath() {
        return path;
    }

    public String getFilter() {
       return filter;
    }  
}

/**
* The ChooseFileCommandHandler.  Performs the real work.
*/
public class ChooseFileCommandHandler implements CommandHandler<ChooseFileCommandParams, File> {
    public File execute(ChooseFileCommandParams params) throws Exception {
       // UI code here to set up the chooser, set look and feel, defaults, etc..
       // of course this won't compile because I made up a fake implementation.
       // the point is to show how the work is encapsulated and nicely parameterized.
       FileChooser chooser = new FileChooser(params.getPath(), params.getFilter());
       chooser.open();
       File chosenFile = chooser.getSelection();
       if (chosenFile == null) {
          new AlertDialog("File not chosen!");
       }
       return chosenFile;
    }
}

/**
* Handles registering command handlers (binding them to commands) and executing.  I called this
* ApplicationContext but it can be any class that's initialized on application startup and accessible to any
* code that needs to execute commands.  Most application frameworks have something like this.
*/
public class ApplicationContext {
    private List<CommandHandlerBinding> commandHandlerBindings;
  
    public void initializeApplication() {
        registerCommandHandler(Command.CHOOSE_FILE, new ChooseFileCommandHandler());
    }

    public <ParamType, ReturnType> void registerCommandHandler(Command<ParamType, ReturnType> command,
            CommandHandler<ParamType, ReturnType> handler) {
        CommandHandler<ParamType, ReturnType> existingHandler = getCommandHandler(command);
        if (existingHandler != null) {
            System.out.println("Command [" + command.getName() + "] already has a handler ["
                    + existingHandler.getClass().getName() + "] but is being set to [" + handler.getClass().getName()
                    + "]");
        }
        commandHandlerBindings.add(new CommandHandlerBinding<ParamType, ReturnType>(command, handler));
    }

    private <ParamType, ReturnType> CommandHandler<ParamType, ReturnType> getCommandHandler(Command<ParamType, ReturnType> command) {
        for (CommandHandlerBinding<ParamType, ReturnType> binding : commandHandlerBindings) {
            if (binding.getCommand().getName().equals(command.getName())) {
                return binding.getHandler();
            }
        }
        return null;
    }

    public <ParamType, ReturnType> ReturnType executeCommand(Command<ParamType, ReturnType> command,
            ParamType parameters) throws Exception {
        CommandHandler<ParamType, ReturnType> handler = getCommandHandler(command);
        if (handler == null) {
            throw new NullPointerException("No CommandHandler registered for Command [" + command.getName() + "]");
        }
        return handler.execute(parameters);
    }
}

/**
* The base class for anything.
*/
public abstract class MyBaseClass {
    private ApplicationContext applicationContext;

    public <ParamType, ReturnType> ReturnType executeCommand(Command<ParamType, ReturnType> command,
            ParamType parameters) throws Exception {
      return getApplicationContext().executeCommand(command, parameters);
    }

    private ApplicationContext getApplicationContext() {
       return applicationContext;
    }
}

/**
* Finally, the top of the stack.  This is the class that is invoking the command.  Looks simple from up
* here, doesn't it?
*/
public class MyClass extends MyBaseClass {

    public void doStuff() {
       System.out.println("Watch me invoke the command");
       File chosenFile = executeCommand(Command.CHOOSE_FILE, new ChooseFileCommandParameters("c:\", "*.txt"));
       System.out.println("The file you chose is: " + chosenFile);
    }
}