Communication entre deux applications de bureau Java distinctes

Question

Je cherche à développer deux applications de bureau Java distinctes (mais liées).

Je veux qu'une application puisse déclencher l'autre, en lui transmettant des données qui peuvent ensuite être éditées et renvoyées, c'est-à-dire que la communication sera bidirectionnelle. Si l'autre application est déjà en cours d'exécution, je veux qu'elles communiquent simplement, c'est-à-dire que je ne veux pas simplement passer des arguments par la ligne de commande, etc.

D'une manière générale, quelles stratégies/techniques dois-je envisager pour y parvenir ?

Answer 1

Pour montrer à quel point il est facile de permettre à deux applications de communiquer entre elles, regardez cette démonstration de tableau de bord réseau utilisant JGroups. Il suffit de lancer deux instances et de commencer à déposer des fichiers dans l'une d'elles. La seconde instance affichera instantanément les mêmes fichiers.

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;
            }

        });
    }

}

Answer 2

Cela dépend de la manière dont vous souhaitez communiquer avec ces deux programmes :

• Si vous n'avez besoin que de sémaphores inter-processus, créez un fichier quelque part dans /tmp et verrouillez-le.

• Si vous n'avez besoin que d'une messagerie synchrone interprocessus (appel de procédure à distance), RMI devrait être le plus simple.

• Si vous avez besoin d'une messagerie interprocessus asynchrone, JMS devrait être le plus simple.

• Si vous avez besoin de mémoire partagée inter-processus, utilisez des fichiers mappés.

• Si vous avez besoin de tout cela, Terracotta (http://www.terracotta.org/ ) est le moyen le plus simple : Les programmes Java sur différentes JVM sur le même ordinateur ou même sur des ordinateurs différents se voient les uns les autres comme s'ils étaient exécutés dans une JVM sur une seule machine. La division d'un programme en plusieurs autres ne nécessite même pas de modification du code - il suffit d'écrire un fichier de configuration XML.

Answer 3

Ils pourraient chacun écouter sur un Socket . Ce tutoriel est bon pour commencer.

Answer 4

Vous devriez également envisager le bon vieux RMI classique.

Answer 5

Jetez un coup d'œil à JavaGroups Cela résoudra votre problème de communication et vous aidera également à détecter si l'autre application est en cours d'exécution. Si l'application n'est pas en cours d'exécution, vous devrez lancer une nouvelle JVM pour elle avec java.lang.Runtime.exec()...