Communication between two separate Java desktop applications

I'm looking to develop two separate (but related) Java desktop applications.

I want the ability for one application to trigger the other, passing in data that can then be edited and passed back, i.e. the communication will be two way. If the other application is already running I want them to just communicate, i.e. I dont want to just pass arguments over the command line, etc.

Generally speaking, what strategies/techniques should I be looking at in order to achieve this?

To show how easy it is to let two applications communicate with each other, check out this network-clipboard demo using JGroups. Just start two instances and begin dropping files into one of them. The second instance will instantly show the same files.

import java.io.Serializable;
import java.awt.*;
import java.awt.datatransfer.*;
import javax.swing.*;
import org.jgroups.*;

public class JGroupsTest {

	public static void main(String[] args) throws Exception {
		final JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setVisible(true);
		frame.setSize(500, 300);
		final DefaultListModel listModel = new DefaultListModel();
		final JList panel = new JList(listModel);
		panel.setBackground(new Color(128, 0, 40));
		panel.setForeground(new Color(240, 240, 240));
		frame.add(panel);
		System.setProperty("java.net.preferIPv4Stack", "true");
		final JChannel channel = new JChannel("udp.xml");
		channel.connect("networkclipboard");
		channel.setReceiver(new ReceiverAdapter() {
			@Override
			public void viewAccepted(View newView) {
				frame.setTitle("Network Clipboard - " + channel.getLocalAddress());
			}

			@Override
			public void receive(Message msg) {
				listModel.addElement(msg.getObject());
			}
		});

		panel.setTransferHandler(new TransferHandler() {
			@Override
			public boolean importData(JComponent comp, Transferable t) {
				DataFlavor[] transferDataFlavors = t.getTransferDataFlavors();
				for (DataFlavor flavor : transferDataFlavors) {
					try {
						Object data = t.getTransferData(flavor);
						if (data instanceof Serializable) {
							Serializable serializable = (Serializable) data;
							Message msg = new Message();
							msg.setObject(serializable);
							channel.send(msg);
						}
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
				return super.importData(comp, t);
			}

			@Override
			public boolean canImport(TransferSupport support) {
				return true;
			}

			@Override
			public boolean canImport(JComponent comp, DataFlavor[] transferFlavors) {
				return true;
			}

		});
	}

}

It depends how would you like to communicate those 2 programs:

• If you need only inter-process semaphores, create a file somewhere in /tmp and lock it.

• If you need only inter-process synchronous messaging (remote procedure call), RMI should be easiest.

• If you need asynchronous interprocess messaging, JMS should be easiest.

• If you need inter-process shared memory, use mapped files.

• If you need all the above, Terracotta (http://www.terracotta.org/ ) is the easiest way: Java programs on different JVMs on the same or even different computers see each other as if they were executed inside one JVM on one machine. Splitting one program into a few doesn't even require any code changes - it's enough to write an XML config file.

They could each listen on a Socket. This tutorial is good to get started.

You should also consider good ol' classic RMI.

Have a look at JavaGroups, it will solve your communication problem and also help you to detect if the other app is running. If the app isn't running you will have to launch a new JVM for it with java.lang.Runtime.exec()...

Try to communicate with SocketCommunication, even if the application are in the same machine.

Here can find more info about how to do it (Sun/Java documentation).

• The "Enterprise" way to go would be to run these apps in a Java EE server or at least in a Spring framework. It's also probably vastly overkill.

• If a bunch of data needs to be communicated, then RMI will do it.

• If you're not afraid to hack your own protocol, data structure and error handling, you can set up server and client sockets and communicate through those.

• I think there's a certain crude appeal to the alternative of communicating via a file in a common directory (setting up your own protocol of who writes or erases the file when), or via a shared database. Low-tech, not extremely fast, but very simple and reliable. And it's fairly easy to monitor "communication" from the outside.

To keep things simple why not just use plain TCP sockets?

I second Socket communication and RMI. RMI is a little more involved but is more intuitive to a programmer. It depends on what type of information you are sending though. Pushing raw bytes over to another machine might make more sense then running the RMI server and dealing with all that jazz...

It depends what kind of communication you want to do between the 2 apps. If you use sockets or RMI for example, both applications need to be up in order for the communication to happen. If the kind of communication you want to do can be more asynchronous then you can use more of a messaging based approach.

For example, ZooKeeper allows you to implement pretty much anything you want on top of very simple yet powerful primitives. This page (http://hadoop.apache.org/zookeeper/docs/current/recipes.html) explains how to build higher level constructs with ZooKeeper.

The drawback is that you need another system. If you use JGroups for example then you don't.

Hope this helps

Depending on what style of communication you're looking for (high latency, lots of data, etc.) and whether or not this system may expand past simply 2 java systems, a possibility could be a messaging system using a middleware solution such as Tibco SmartSockets.

Any more info on your setup and expectations would help.

The easiest is to use RMI without standalone rmiregistry.

Server creates a local registry:

ServerImpl extends UnicastRemoteObject implements Server

rmiRegistry = LocateRegistry.createRegistry(2020);
rmiRegistry.bind("server", aServerImpl);

Client looks it up with an rmi url (similar to corbaloc:)

String url = "rmi://localhost:2020/server";
Server server = (Server) Naming.lookup(url);

I got 1000 calls in under 500 ms in a loop over the same open connection. Yes, that is milliseconds.

Idea and sample from here: https://www.censhare.com/us/resources/blog/article/file-streaming-using-java-rmi