Eine erste Message

Ein Target, welches sich selbst eine Message zuschickt.

Hier sieht man, wie das Target002 einige LOG-Ausgaben macht. Es gibt seine devel.one-Adresse sowie die Bestandteile dieser Adresse aus. Anschließend schickt es sich selbst eine Message zu.

final class CTarget002 extends CTarget
{
    private static final IId TESTID001 = CIdFactory.create("Hurray!");

    CTarget002()
    {
        addMessageHandler(CRecordStartTarget.ID, new IMessageHandler()
        {
            @Override
            public boolean handleMessage(final CEnvelope aEnvelope,
                                         final CRecord aRecord) throws Exception
            {
                final ITargetAddress address = getAddress();
                final IId tid = address.getTID();
                final IId nid = address.getNID();
                final INodeID nodeID = address.getNodeID();

                CConstants.LOG.debug("Example001Target002: My address is {}", address);
                CConstants.LOG.debug("Example001Target002: My target ID is {}", tid);
                CConstants.LOG.debug("Example001Target002: My namespace ID is {}", nid);
                CConstants.LOG.debug("Example001Target002: My node ID is {}", nodeID);

                // I want to send a message to myself.
                triggerThisTarget(TESTID001);
                
                // means success
                aEnvelope.setResult(null);

                // means we have consumed this message
                return true;
            }

        });

        // catch the message for me.
        addMessageHandler(TESTID001, new IMessageHandler()
        {
            @Override
            public boolean handleMessage(final CEnvelope aEnvelope,
                                         final CRecord aRecord) throws Exception
            {
                CConstants.LOG.debug(aRecord.getId().toString());

                aEnvelope.setResult(null);
                return true;
            }
        });
    }
}

Die Target-Adresse ist wichtig. Jeder, der die Adresse des Targets kennt, kann Messages direkt an dieses Target senden. Das funktioniert auch, wenn sich der Sender in einem ganz anderen NODE auf einem weit entfernten Computer im selben devel.one-Netz befindet. Damit meinen wir nicht das lokale Netz, sondern das Peer-to-Peer Netz aus miteinander verbundenen devel.one-NODES.

In diesem Target wird lediglich ein einfacher Trigger ohne Daten versandt. Dazu wird eine Message-ID - oder genauer - Record-ID benötigt. Diese legen wir über dem Konstruktor mittels der ID-Factory an. Diese IDs können aus einem Integer, einem String oder einer UUID bestehen, wie es dem Programmierer gefällt. Integer sind schön klein, Strings gut lesbar, und UUID kollisionssicher. Die Nachricht wird intern mit triggerThisTarget() versandt, eine Convenience-Methode.

Die Nachricht an uns selbst wird in einem zweiten MessageHandler aufgefangen. Dort wird einfach die Record-ID> protokolliert (Hurray!). Der Record trägt außer der ID auch noch die Nutzdaten einer Message. Das ist in diesem einfachen Beispiel nicht der Fall, weil keine Daten versandt wurden.

Natürlich muss auch dieses Target vorher registriert werden. Das machen wir etwas anders als beim ersten Target, weil wir eine ID mitgeben:

final IId TID002 = CIdFactory.create("Arthur");
aNamespace.getTargetRegistry().registerTarget(new CTarget002(), TID002);

Das Target bekommt eine ID "Arthur". Normalerweise benötigt man keine Target-ID, da man selten Nachrichten direkt an ein Target schickt. Denn dazu muss man natürlich die Target-ID kennen. Aber es wäre ziemlich umständlich, wenn die Targets, die sich gegenseitig Nachrichten zuschicken, hart verdrahtet wären. Dafür benutzt man lieber Services, die wir etwas später kennen lernen.