Ziel

Wir bringen Sie an den Punkt, an dem Sie mit Watson Slack Bot und Line Bot auch ohne Wissen erstellen können.

[Aktualisiert am 6. Juni 2019] Dieser Beitrag wurde während der Watson Conversation-Ära, dem Vorgänger von Watson Assistant, verfasst. Obwohl die Screenshots noch alt sind, sind die grundlegenden Ideen und Vorgänge von Watson Assitant noch nicht abgeschlossen Ändert sich nicht, lesen Sie es daher bitte als die neueste Umgebung. </ font>

■ Ich möchte Folgendes ansprechen.

(1) Einführung in das Denken, Erstellen eines Kontos ② Entwurfsmethode für den Dialogfluss am Beispiel "Hotelreservierung" ③ Verwendung des Kontexts, praktische Verwendung verschiedener Funktionen, die im Lernprogramm nicht erwähnt werden ** ④ Verknüpfung mit Java-Logik ** ← Dieser Artikel ⑤ Erstellen Sie einen Chatbot mit Watson + Java + Slack

Dieses Mal werden wir als Teil 4 erklären, wie man mit Java-Logik verknüpft.

Klicken Sie hier zum letzten Mal → ③ Verwendung des Kontexts, praktische Verwendung verschiedener Funktionen, die im Tutorial nicht erwähnt werden.

Dieses Mal werden wir Java-Logik und Watson Conversation verbinden.

Vorbereitung des Arbeitsbereichs für die Betriebsprüfung

Erstellen Sie zunächst einen einfachen Arbeitsbereich, um die Funktionsweise des Programms zu überprüfen.

Die ** Arbeitsbereichsdatei (JSON) ** für die Betriebsprüfung kann wie folgt heruntergeladen werden. https://riversun.github.io/wcs/org.riversun.WcsContextTestJa.zip

Wenn Sie dies importieren, haben Sie einen Arbeitsbereich mit nur zwei Knoten, wie unten gezeigt.

Welcome_node
Der erste ** Welcome_node ** ist der erste auszuführende Knoten. Ich habe hier mehrere Kontextvariablen festgelegt.

{
  "context": {
    "myParam01": "banana",
    "myParam02": "apple",
    "myParam03": 7777,
    "myParam04": true,
    "myParam05": {
      "subParam01": "orange",
      "subParam02": "lemon"
    }
  },
 ...
}

Show_Context_node
Der zweite ** Show_Context_node ** wird nach Benutzereingabe unmittelbar nach der Ausführung von Welcome_node ausgeführt.

Die Antwort dieses Knotens lautet

** Sie sagten "". Der Wert der Kontextvariablen myRemoteParam lautet "". ** ** **

Gibt den Eingabetext des Benutzers und die Kontextvariable ** myRemoteParam ** zurück.

Zusammenarbeit mit Java-Programmen

Überprüfen Sie die Arbeitsbereichsdaten

Um den Watson Conversation-Dialogfluss von einem Java-Programm aus auszuführen, benötigen Sie die ** WorkspaceId **, ** Username ** und ** Password ** des Arbeitsbereichs.

Um diese anzuzeigen, klicken Sie auf das Symbol ** Bereitstellen ** auf der linken Seite des Dialogfeld-Editors (siehe Abbildung unten), um den Bereich ** Bereitstellen ** zu öffnen und die Registerkarte ** Anmeldeinformationen ** auszuwählen. Notieren Sie sich ** WorkspaceId **, ** Benutzername ** bzw. ** Passwort **. Sie werden diese später in Ihrem Java-Programm verwenden.

Beispielcode

Der unten eingeführte Beispielcode kann aus dem folgenden öffentlichen Repository abgerufen werden. https://github.com/riversun/watson-conversation-java-examples-ja

Beispiel 01: Senden Sie eine Nachricht von der Java-Logik an Watson Conversation, um den Arbeitsbereich auszuführen, und legen Sie die Kontextvariable fest

Unten finden Sie den Code, der eine Textnachricht an Watson sendet. Stellen Sie außerdem die Kontextvariable von Java auf Watson Conversation ein.

`WcsExample01.java`



package org.example.wcs;

import org.riversun.wcs.WcsClient;

import com.ibm.watson.developer_cloud.conversation.v1.model.MessageResponse;

public class WcsExample01 {

	private static final String WCS_USERNAME = "EDIT_ME_USERNAME_HERE";
	private static final String WCS_PASSWORD = "EDIT_ME_PASSWORD_HERE";
	private static final String WCS_WORKSPACE_ID = "EDIT_ME_WORKSPACE_ID_HERE";

	public static void main(String[] args)
	{

		String wcsClientId = "dummy_user_id";
		WcsClient watson = new WcsClient(WCS_USERNAME, WCS_PASSWORD, WCS_WORKSPACE_ID);

		MessageResponse wcsWelcomeRes = watson.startConversation(wcsClientId);

		System.out.println("FROM WATSON:" + wcsWelcomeRes.getTextConcatenated(""));

		final String ctxKey = "myRemoteParam";
		final String ctxValue = "I need you!";
		watson.put(wcsClientId, ctxKey, ctxValue);

		final String myMessage01 = "Hi! Watson";
		MessageResponse wcsRes01 = watson.sendMessage(wcsClientId, myMessage01);
		System.out.println("FROM WATSON:" + wcsRes01.getTextConcatenated(""));

	}
}

Codebeschreibung

private static final String WCS_USERNAME = "EDIT_ME_USERNAME_HERE";//username
private static final String WCS_PASSWORD = "EDIT_ME_PASSWORD_HERE";//password
private static final String WCS_WORKSPACE_ID = "EDIT_ME_WORKSPACE_ID_HERE";//workspaceId

Legen Sie zunächst die Anmeldeinformationen für den Zugriff auf Watson fest. Bearbeiten Sie den folgenden Teil des Codes und ersetzen Sie ihn durch die ** Arbeitsbereich-ID, den Benutzernamen und das Kennwort **, die Sie zuvor im Bereich ** Bereitstellen ** gesehen haben.

 String wcsClientId = "dummy_user_id";

Bei der Arbeit mit Watson Conversation mithilfe der Hilfsbibliothek Geben Sie eine eindeutige Benutzer-ID an, um den Benutzer zu identifizieren (hier lautet der Variablenname wcsClientId. Beachten Sie, dass er sich vollständig vom Benutzernamen des Arbeitsbereichs unterscheidet).

Die Benutzer-ID ist kein für Watson Conversation einzigartiges Konzept. Wenn jedoch mehrere Benutzer gleichzeitig mit dem Bot mit einem Chat-Bot usw. interagieren (siehe unten), wird der Interaktionsstatus zwischen dem Benutzer und dem Chat-Bot für jeden Benutzer beibehalten (selbstverständlich). Muss sein

Daher kann wie in diesem Beispiel auch ein Benutzer auf Watson zugreifen, indem er der Einfachheit halber eine Benutzer-ID zuweist. (Übrigens wird bei der internen Verarbeitung von Watson für jede Konversationssitzung und nicht für jeden Benutzer eine ID namens Gesprächs-ID zugewiesen.)

 WcsClient watson = new WcsClient(username,password,workspaceId);

Neu die WcsClient-Klasse. Diese Klasse kommuniziert mit Watson-Konversation

MessageResponse wcsWelcomeRes = watson.startConversation(wcsClientId);
System.out.println("FROM WATSON:" + wcsWelcomeRes.getTextConcatenated(""));

Der erste Aufruf verwendet die Methode ** # startConversation **. Ich denke, dass der Knoten von Watson Conversation oft ein ** Willkommensknoten ** ist, aber ** #startConversation ** führt diesen ** Willkommensknoten ** aus. Erhalten Sie die Antwort von Watson als ** MessageResponse **.

** #getTextConcatenated ** dient zum Abrufen der Antwort von Watson als Zeichenfolge. (Die eigentliche Antwort von Watson ist ein JSON-String-Array-Typ (= List in Java), da er möglicherweise mehrere Knoten durchläuft, bevor eine Antwort zurückgegeben wird, aber diese Antwort vom Typ String-Array Werden kombiniert und als eine Zeichenfolge erhalten.)

final String ctxKey = "myRemoteParam";
final String ctxValue = "I need you!";
watson.put(wcsClientId, ctxKey, ctxValue);

Mit ** watson.put (Benutzer-ID, Name der Kontextvariablen, Wert der Kontextvariablen) ** wird die ** Kontextvariable ** von Watson Conversation von der Java-Logikseite aus festgelegt.

Hier setze ich den Wert "** Ich brauche dich! **" auf die Kontextvariable ** myRemoteParam **.

Zu diesem Zeitpunkt wird der Kontext nur in der Java-Logik gespeichert und beim nächsten Zugriff auf Watson über die Java-Logik auf der Watson-Seite angezeigt.

final String myMessage01 = "Hi! Watson";
MessageResponse wcsRes01 = watson.sendMessage(wcsClientId, myMessage01);
System.out.println("FROM WATSON:" + wcsRes01.getTextConcatenated(""));

Senden Sie eine Textnachricht an Watson mit ** #sendMessage (Benutzer-ID, Nachricht) **. Zu diesem Zeitpunkt wird die zuvor festgelegte Kontextvariable auf der Watson-Seite wiedergegeben.

Hier wird die Nachricht "** Hi! Watson **" von der Java-Logik gesendet.

Die Antwort des Knotens ** Show_Context_node ** auf der Watson-Konversationsseite lautet übrigens Sie sagten "**" ". Der Wert der Kontextvariablen myRemoteParam lautet "". ** ”

Daher lautet die Antwort von Watson, die auf der Java-Logikseite empfangen wurde, wie folgt.

`Antwort`


「Hi!Sie sagten "Watson". Der Wert der Kontextvariablen myRemoteParam lautet "Ich brauche dich!"ist.


 final String myMessage02 = "Hello! Watson";
        String wcsResText = watson.sendMessageForText(wcsClientId, myMessage02);
        System.out.println("FROM WATSON:" + wcsResText);

** # sendMessageForText ** sendet eine Textnachricht an Watson wie ** # sendMessage **, aber da es auch die Antwort von Watson als Text empfängt, ist diese Methode die einfachste zum Senden und Empfangen von Text.

Wenn Sie ** # sendMessageForText ** verwenden, können Sie auch ** # startConversation ** weglassen (dh *** startConversation ** im ersten ** # sendMessageForText ** ausführen). ), Wenn Sie einen Chatbot erstellen möchten, der nur Text sendet und empfängt, benötigen Sie lediglich die Methode ** # sendMessageForText **.

Ergebnis der Programmausführung

Wenn Sie WcsExample01.java ausführen, wird es wie folgt an die Konsole ausgegeben

`Ausführungsergebnis`


FROM WATSON:Hallo, ich bin Watson
FROM WATSON:「Hi!Sie sagten "Watson". Der Wert der Kontextvariablen myRemoteParam lautet "Ich brauche dich!"ist.
FROM WATSON:「Hello!Sie sagten "Watson". Der Wert der Kontextvariablen myRemoteParam lautet "Ich brauche dich!"ist.

Bibliotheksabhängigkeiten

Um den obigen Code auszuführen, stellen Sie die abhängigen Bibliotheken wie folgt ein

`maven`


<dependency>
    <groupId>org.riversun</groupId>
    <artifactId>wcs</artifactId>
    <version>1.0.2</version>
</dependency>

`gradle`


compile 'org.riversun:wcs:1.0.2'

Wir haben Watson-Conversation-Service-für-Java als Hilfsbibliothek für die Ausführung von Watson Conversation aus Java vorbereitet. Diese Bibliothek ist eine Erweiterung der gut gemachten Basisbibliothek für Mehrbenutzer-Chatbots.

Beispiel 02: Watsons Kontextvariable aus der Java-Logik abrufen

Das folgende Beispiel zeigt, wie die Kontextvariable auf der Watson-Konversationsseite festgelegt wird.

`WcsExample02.java`


package org.example.wcs;

import java.util.Map;

import org.riversun.wcs.WcsClient;

public class WcsExample02 {

	private static final String WCS_USERNAME = "EDIT_ME_USERNAME_HERE";
	private static final String WCS_PASSWORD = "EDIT_ME_PASSWORD_HERE";
	private static final String WCS_WORKSPACE_ID = "EDIT_ME_WORKSPACE_ID_HERE";

	public static void main(String[] args)
	{

		String wcsClientId = "dummy_user_id";

		WcsClient watson = new WcsClient(WCS_USERNAME, WCS_PASSWORD, WCS_WORKSPACE_ID);

		watson.startConversation(wcsClientId);

		String myParam01 = watson.getAsString(wcsClientId, "myParam01");
		System.out.println("myParam01=" + myParam01);

		String myParam02 = watson.getAsString(wcsClientId, "myParam02");
		System.out.println("myParam02=" + myParam02);

		Integer myParam03 = watson.getAsInteger(wcsClientId, "myParam03");
		System.out.println("myParam03=" + myParam03);

		Boolean myParam04 = watson.getAsBoolean(wcsClientId, "myParam04");
		System.out.println("myParam04=" + myParam04);

		Map<String, Object> myParam05 = watson.getAsMap(wcsClientId, "myParam05");

		String subParam01 = (String) myParam05.get("subParam01");
		System.out.println("myParam05.subParam01=" + subParam01);

		String subParam02 = (String) myParam05.get("subParam02");
		System.out.println("myParam05.subParam02=" + subParam02);

	}
}

Codebeschreibung

Wie oben dargestellt, lauten die im Knoten ** Welcome_node ** auf der Watson-Konversationsseite festgelegten Kontextvariablen wie folgt.

{
  "context": {
    "myParam01": "banana",
    "myParam02": "apple",
    "myParam03": 7777,
    "myParam04": true,
    "myParam05": {
      "subParam01": "orange",
      "subParam02": "lemon"
    }
  }
}

Um beispielsweise die obige Kontextvariable "** myParam01 **" auf der Java-Seite abzurufen, gehen Sie wie folgt vor.

String myParam01 = watson.getAsString(Benutzeridentifikation, "myParam01");

Wenn Sie ein (verschachteltes) zusammengesetztes Objekt wie die Kontextvariable "** myParam05 **" verwenden, erhalten Sie es wie unten gezeigt als ** Map **. Die Daten werden verschachtelt unter ** Map ** gespeichert.

**Map<String, Object> myParam05 = watson.getAsMap(wcsClientId, "myParam05");**

Die folgende Tabelle zeigt auch, wie Sie auf andere Typen zugreifen können.

** Methode zum Abrufen der Watson Conversation Context-Variablen aus der Java-Logik **

Typ der Kontextvariablen	Methodendefinition	Rückgabetyp
Zeichenfolgentyp	#getAsString(Benutzeridentifikation,Name der Kontextvariablen)	String
Numerischer Typ(Ganzzahliger Typ)	#getAsInteger(Benutzeridentifikation,Name der Kontextvariablen)	Integer
Numerischer Typ(Doppeltyp)	#getAsDouble(Benutzeridentifikation,Name der Kontextvariablen)	Double
Boolescher Typ	#getAsBoolean(Benutzeridentifikation,Name der Kontextvariablen)	Boolean
Komplexer Typ(Wenn der JSON verschachtelt ist)	#getAsMap(Benutzeridentifikation,Name der Kontextvariablen)	Map

Beispiel 03: Behandeln Sie Watson-Antwortdetails aus einem Java-Programm

In den beiden obigen Beispielen haben wir uns hauptsächlich mit dem Senden und Empfangen von Text (String) und dem Austausch von Kontextvariablen befasst. Sie können jedoch tatsächlich verschiedene Informationen zwischen Watson- und Java-Logik abrufen.

** Informationen, die erhalten werden können **

Information	Erläuterung
Input	Benutzereingabeinformationen
Output	Informationen von Watson ausgeben. Andere Informationen als Text können flexibel in die Ausgabe aufgenommen werden
Context	Informationen zu Kontextvariablen
Intents	Absicht bestimmt von Watson basierend auf Benutzereingabetext(Mehrere)
Entities	Von Watson basierend auf Benutzereingabetext extrahierte Entität(Mehrere)

Das Folgende ist ein Beispiel für den Zugriff auf verschiedene Informationen, die tatsächlich in der Antwort von Watson über die Java-Logik enthalten sind.

public class WcsExample03 {

	private static final String WCS_USERNAME = "EDIT_ME_USERNAME_HERE";
	private static final String WCS_PASSWORD = "EDIT_ME_PASSWORD_HERE";
	private static final String WCS_WORKSPACE_ID = "EDIT_ME_WORKSPACE_ID_HERE";

	public static void main(String[] args)
	{

		String wcsClientId = "dummy_user_id";
		WcsClient watson = new WcsClient(WCS_USERNAME, WCS_PASSWORD, WCS_WORKSPACE_ID);

		MessageResponse res = watson.startConversation(wcsClientId);

		Map<String, Object> context = res.getContext();

		Map<String, Object> input = res.getInput();

		String inputText = res.getInputText();

		List<Intent> intents = res.getIntents();

		List<Entity> entities = res.getEntities();

		Map<String, Object> output = res.getOutput();

		List<String> text = res.getText();

		String textConcatenated = res.getTextConcatenated("");

		System.out.println("Response JSON from Watson=\n" + res.toString());

	}
}

Aktuelle Antwort von Watson (JSON)

Da Java über eine Hilfsbibliothek verfügt, gibt es nicht viele Szenen, in denen Java-Logik JSON direkt analysiert. Die tatsächliche Antwort von Watson Conversation lautet jedoch wie folgt.

`Antwort von Watson Conversation`



{
  "context": {
    "system": {
      "dialog_stack": [
        {
          "dialog_node": "root"
        }
      ],
      "dialog_turn_counter": 2.0,
      "dialog_request_counter": 2.0,
      "_node_output_map": {
        "Welcome_Node": [
          0.0
        ],
        "Show_Context_Node": [
          0.0
        ]
      },
      "branch_exited": true,
      "branch_exited_reason": "completed"
    },
    "conversation_id": "xxxx-xxxxxx-xxxxx-xxxx",
    "myParam05": {
      "subParam01": "orange",
      "subParam02": "lemon"
    },
    "myRemoteParam": "I need you!",
    "myParam03": 7777.0,
    "myParam04": true,
    "myParam01": "banana",
    "myParam02": "apple"
  },
  "entities": [],
  "intents": [],
  "output": {
    "text": [
      "「Hi!Sie sagten "Watson". Der Wert der Kontextvariablen myRemoteParam lautet "Ich brauche dich!"ist."
    ],
    "nodes_visited": [
      "Show_Context_Node"
    ],
    "log_messages": []
  },
  "input": {
    "text": "Hi!Watson"
  }
}

Beispiel 04: Erstellen Sie eine GUI mit Java und lassen Sie sie wie einen Chatbot aussehen

Dieser Abschnitt ist ein kleines Extra.

Es ist ein wenig schwierig, die Watson Conversation-Interaktion nur mit einer Java-Konsolen-App zu testen. Deshalb habe ich eine einfache GUI erstellt.

・ Der gesamte Quellcode befindet sich im folgenden Repository https://github.com/riversun/watson-examples-java-chatbot

・ Der Dialogablauf ist der ** Hotelreservierungs-Chatbot (erweiterte Version) **, der [Letztes Mal] eingeführt wurde (http://qiita.com/riversun/items/53cd59e1405d7c77f32c). Sie können die Arbeitsbereichsdatei (JSON) wie folgt herunterladen. https://riversun.github.io/wcs/org.riversun.HotelReservationV2.zip

Codebeispiel

@SuppressWarnings("serial")
public class WatsonChat extends JFrame {

    private static final String WATSON_CONVERSATION_USERNAME = "EDIT HERE";
    private static final String WATSON_CONVERSATION_PASSWORD = "EDIT HERE";
    private static final String WATCON_CONVERSATION_WORKSPACE_ID = "EDIT HERE";
    private static final String WCS_CLIENT_ID = "dummy_user_id";

    private static final int WIDTH_PX = 640;
    private static final int HEIGHT_PX = 480;

    private final WcsClient mWatson = new WcsClient(WATSON_CONVERSATION_USERNAME, WATSON_CONVERSATION_PASSWORD, WATCON_CONVERSATION_WORKSPACE_ID);

    private final ExecutorService mExecutor = Executors.newSingleThreadExecutor();
    private final StringBuilder mSb = new StringBuilder();

    private final JTextArea mTextArea = new JTextArea();
    private final JTextField mTextBox = new JTextField("");

    public static void main(String args[]) {

        EDTHandler.post(new Runnable() {
            public void run() {

                System.setProperty("jsse.enableSNIExtension", "false");
                try {
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (ClassNotFoundException | InstantiationException |
                        IllegalAccessException | UnsupportedLookAndFeelException e) {
                }

                final WatsonChat frame = new WatsonChat();
                frame.setVisible(true);
            }
        });
    }

    public WatsonChat() {
        EDTHandler.post(new Runnable() {
            @Override
            public void run() {
                buildGUI();
                sendMessageOnFirst();
            }
        });
    }

    boolean onUserInputText(String userInputText) {

        addTextIntoHistory("YOU:" + userInputText + "\n");

        sendMessageToWatson(WCS_CLIENT_ID, userInputText);

        return true;
    }

    void onClearButtonPressed() {
        mSb.setLength(0);
        EDTHandler.post(new Runnable() {
            @Override
            public void run() {
                mTextArea.setText(mSb.toString());
            }
        });
        mWatson.clearConversation(WCS_CLIENT_ID);
        sendMessageOnFirst();
    }

    void sendMessageOnFirst() {

        mExecutor.submit(new Runnable() {
            @Override
            public void run() {
                MessageResponse welcomeRes = mWatson.startConversation(WCS_CLIENT_ID);
                addTextIntoHistory("WATSON:" + welcomeRes.getTextConcatenated("") + "\n");
                unlockTextBox();
            }
        });
    }

    void sendMessageToWatson(String wcsClientId, String userInputText) {

        mExecutor.submit(new Runnable() {
            @Override
            public void run() {

                final String watsonOutputText = mWatson.sendMessageForText(wcsClientId, userInputText);
                addTextIntoHistory("WATSON:" + watsonOutputText);

                unlockTextBox();
            }
        });
    }

    void addTextIntoHistory(String text) {

        mSb.append(text);
        EDTHandler.post(new Runnable() {
            @Override
            public void run() {
                mTextArea.setText(mSb.toString());
            }
        });

    }

    void unlockTextBox() {

        EDTHandler.post(new Runnable() {
            @Override
            public void run() {

                mTextBox.setEditable(true);
                mTextBox.requestFocus();
                mTextBox.getCaret().setVisible(true);
                mTextBox.setCaretPosition(0);

            }
        });
    }

    void buildGUI() {

        setTitle("Chat with Watson");
        setSize(WIDTH_PX, HEIGHT_PX);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        final JLinearLayout layoutParent = new JLinearLayout().setChildOrientation(Orientation.VERTICAL).setPadding(5);
        final JLinearLayout layoutHeader = new JLinearLayout().setChildOrientation(Orientation.HORIZONTAL).setPadding(5, 0, 5, 0);
        final JLinearLayout layoutCenter = new JLinearLayout().setChildOrientation(Orientation.VERTICAL).setPadding(5, 0, 5, 0);
        final JLinearLayout layoutFooter = new JLinearLayout().setChildOrientation(Orientation.VERTICAL).setPadding(5);

        JLabel lbChatHistory = new JLabel("Chat History:");

        JButton btClear = new JButton("Clear");
        btClear.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent arg0) {
                onClearButtonPressed();
            }
        });

        mTextArea.setLineWrap(true);
        mTextArea.setMargin(new Insets(4, 4, 4, 4));
        mTextArea.setEditable(false);

        JScrollPane textAreaScroll = new JScrollPane(mTextArea);
        textAreaScroll.setBorder(new LineBorder(Color.black, 1, true));

        JLabel lbInputText = new JLabel("Input Text:  (press ENTER-KEY to send)");

        mTextBox.setBorder(new LineBorder(Color.black, 1, true));
        mTextBox.setEditable(false);
        Font font = mTextBox.getFont().deriveFont(Font.PLAIN, 20f);
        mTextBox.setFont(font);
        mTextBox.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {

                final String userInputText = mTextBox.getText();

                if ("".equals(userInputText)) {
                    return;
                }

                mTextBox.setEditable(false);

                final boolean consumed = onUserInputText(userInputText);

                if (consumed) {
                    mTextBox.setText("");
                }

            }
        });

        addWindowListener(new WindowAdapter() {
            public void windowOpened(WindowEvent e) {
                mTextBox.requestFocus();
            }
        });

        layoutHeader.addView(lbChatHistory, 1.0d);
        layoutHeader.addView(btClear, 0d);
        layoutCenter.addView(textAreaScroll);
        layoutFooter.addView(lbInputText);
        layoutFooter.addView(mTextBox);
        layoutParent.addView(layoutHeader, 0.0d);
        layoutParent.addView(layoutCenter, 1.0d);
        layoutParent.addView(layoutFooter, 0.0d);
        JPanel mainPanel = layoutParent.getAsPanel();
        Container contentPane = getContentPane();
        contentPane.add(mainPanel, BorderLayout.CENTER);

    }
}

Codebeschreibung

 void sendMessageToWatson(String wcsClientId, String userInputText) {

        mExecutor.submit(new Runnable() {
            @Override
            public void run() {

                final String watsonOutputText = mWatson.sendMessageForText(wcsClientId, userInputText);
                addTextIntoHistory("WATSON:" + watsonOutputText);

                unlockTextBox();
            }
        });
    }

Der Schlüssel zu diesem Code wird hier meistens zusammengefasst.

Der aus dem Textfeld (unten) eingegebene Text wird mit ** # sendMessageForText ** an Watson gesendet. Das Ergebnis wird als Text empfangen und im Textbereich (oben) der Verlaufsanforderung angezeigt.

Der Teil ** lockTextBox ** entsperrt das Textfeld. Wenn Sie das Textfeld während der Kommunikation mit Watson nicht sperren, wird der nächste Text gesendet, bevor das Ergebnis zurückgegeben wird.

Der Rest ist ein Teil, der häufig in der GUI-Verarbeitung zu finden ist, aber der Teil von ** mExecutor.submit ** verwendet Thread Executor, um mit Watson in einem separaten Thread zu kommunizieren. Wenn Sie hier synchronisieren, wird die GUI während der Kommunikation mit Watson gesperrt.

Zusammenfassung

Dieses Mal habe ich vorgestellt, wie Java-Logik und Watson-Konversation verknüpft und der Dialogfluss von Watson-Konversation von Java ausgeführt wird.

Beispielcode-Repository https://github.com/riversun/watson-conversation-java-examples-ja

--Helfer Library Repository https://github.com/riversun/watson-conversation-service-for-java

Nächstes Mal möchte eine Verbindung mit Frontends wie Slack und LINE herstellen, um Chat-Bot-Apps wie Slack Bot und LINE Bot zu erstellen.

Gehen wir zu Watson Assistant (ehemals Conversation). ④ Verknüpfung mit Java-Logik

Ziel

Vorbereitung des Arbeitsbereichs für die Betriebsprüfung

Zusammenarbeit mit Java-Programmen

Überprüfen Sie die Arbeitsbereichsdaten

Beispielcode

Beispiel 01: Senden Sie eine Nachricht von der Java-Logik an Watson Conversation, um den Arbeitsbereich auszuführen, und legen Sie die Kontextvariable fest

WcsExample01.java

Codebeschreibung

Antwort

Ergebnis der Programmausführung

Ausführungsergebnis

Bibliotheksabhängigkeiten

maven

gradle

Beispiel 02: Watsons Kontextvariable aus der Java-Logik abrufen

WcsExample02.java

Codebeschreibung

Beispiel 03: Behandeln Sie Watson-Antwortdetails aus einem Java-Programm

Aktuelle Antwort von Watson (JSON)

Antwort von Watson Conversation

Beispiel 04: Erstellen Sie eine GUI mit Java und lassen Sie sie wie einen Chatbot aussehen

Codebeispiel

Codebeschreibung

Zusammenfassung

`WcsExample01.java`

`Antwort`

`Ausführungsergebnis`

`maven`

`gradle`

`WcsExample02.java`

`Antwort von Watson Conversation`