Connettere il dispositivo all'hub IoT usando JavaConnect your device to your IoT hub using Java

IntroduzioneIntroduction

L'hub IoT di Azure è un servizio completamente gestito che consente comunicazioni bidirezionali affidabili e sicure tra milioni di dispositivi IoT (Internet delle cose) e un back-end della soluzione.Azure IoT Hub is a fully managed service that enables reliable and secure bi-directional communications between millions of Internet of Things (IoT) devices and a solution back end. Una delle maggiori difficoltà con i progetti IoT consiste nel connettere in modo affidabile e sicuro i dispositivi al back-end della soluzione.One of the biggest challenges that IoT projects face is how to reliably and securely connect devices to the solution back end. Per affrontare questa sfida, l'hub IoT:To address this challenge, IoT Hub:

  • Offre messaggistica affidabile da dispositivo a cloud e da cloud a dispositivo su vasta scala.Offers reliable device-to-cloud and cloud-to-device hyper-scale messaging.
  • Rende possibili comunicazioni sicure mediante le credenziali di sicurezza per i singoli dispositivi e il controllo di accesso.Enables secure communications using per-device security credentials and access control.
  • Comprende librerie di dispositivi per i linguaggi e le piattaforme più diffusi.Includes device libraries for the most popular languages and platforms.

Questa esercitazione illustra come:This tutorial shows you how to:

  • Usare il portale di Azure per creare un hub IoT.Use the Azure portal to create an IoT hub.
  • Creare un'identità del dispositivo nell'hub IoT.Create a device identity in your IoT hub.
  • Creare un'app per dispositivo simulato che invii dati di telemetria al back-end della soluzione.Create a simulated device app that sends telemetry to your solution back end.

Al termine di questa esercitazione si avranno tre app di console Java:At the end of this tutorial, you have three Java console apps:

  • create-device-identity, che crea un'identità di dispositivo e una chiave di sicurezza associata per connettere l'app per dispositivi.create-device-identity, which creates a device identity and associated security key to connect your device app.
  • read-d2c-messages, che visualizza i dati di telemetria inviati dall'app per dispositivi.read-d2c-messages, which displays the telemetry sent by your device app.
  • simulated-device, che si connette all'hub IoT con l'identità del dispositivo creata in precedenza e invia un messaggio di telemetria ogni secondo usando il protocollo MQTT.simulated-device, which connects to your IoT hub with the device identity created earlier, and sends a telemetry message every second using the MQTT protocol.

Nota

L'articolo Azure IoT SDK offre informazioni sui vari Azure IoT SDK che è possibile usare per compilare applicazioni da eseguire nei dispositivi e il backend della soluzione.The article Azure IoT SDKs provides information about the Azure IoT SDKs that you can use to build both apps to run on devices and your solution back end.

Per completare l'esercitazione, sono necessari gli elementi seguenti:To complete this tutorial, you need the following:

Creare un hub IoTCreate an IoT hub

Creare un hub IoT per connettere l'app per dispositivo simulato.Create an IoT hub for your simulated device app to connect to. La procedura seguente illustra come completare questa attività usando il portale di Azure.The following steps show you how to complete this task by using the Azure portal.

  1. Accedere al portale di Azure.Sign in to the Azure portal.
  2. Selezionare Nuovo > Internet delle cose > Hub IoT.Select New > Internet of Things > IoT Hub.

    Indice del portale di Azure

  3. Nel riquadro Hub IoT immettere le informazioni seguenti per l'hub IoT:In the IoT hub pane, enter the following information for your IoT hub:

    • Nome: creare un nome per l'hub IoT.Name: Create a name for your IoT hub. Se il nome immesso è valido, viene visualizzato un segno di spunta verde.If the name you enter is valid, a green check mark appears.

    Importante

    L'hub IoT sarà individuabile pubblicamente come endpoint DNS, quindi evitare di indicare informazioni riservate nell'assegnazione del nome.The IoT hub will be publicly discoverable as a DNS endpoint, so make sure to avoid any sensitive information while naming it.

    • Piano tariffario e livello di scalabilità: per questa esercitazione selezionare il livello F1 gratuito.Pricing and scale tier: For this tutorial, select the F1 - Free tier. Per altre informazioni, vedere la pagina relativa a piano tariffario e livello di scalabilità.For more information, see the Pricing and scale tier.

    • Gruppo di risorse: creare un gruppo di risorse per ospitare l'hub IoT o usarne uno esistente.Resource group: Create a resource group to host the IoT hub or use an existing one. Per altre informazioni, vedere l'articolo su come usare i gruppi di risorse per gestire le risorse di Azure.For more information, see Use resource groups to manage your Azure resources

    • Località: selezionare la località più vicina.Location: Select the closest location to you.

    • Aggiungi al dashboard: selezionare questa opzione per semplificare l'accesso all'hub IoT dal dashboard.Pin to dashboard: Check this option for easy access to your IoT hub from the dashboard.

      Finestra Hub IoT

  4. Fare clic su Crea.Click Create. La creazione dell'hub IoT può richiedere alcuni minuti.Your IoT hub might take a few minutes to create. È possibile monitorare lo stato di avanzamento nel riquadro Notifiche.You can monitor the progress in the Notifications pane.

Ora che è stato creato un hub IoT, individuare le informazioni importanti che consentono di connettere dispositivi e applicazioni all'hub IoT.Now that you have created an IoT hub, locate the important information that you use to connect devices and applications to your IoT hub.

  1. Dopo avere creato l'hub IoT, fare clic sul nuovo riquadro dell'hub IoT nel portale di Azure per aprire la finestra delle proprietà.When the IoT hub has been created successfully, click the new tile for your IoT hub in the Azure portal to open the properties window for the new IoT hub. Annotare il Nome host, quindi fare clic su Criteri di accesso condiviso.Make a note of the Hostname, and then click Shared access policies.

    Finestra del nuovo hub IoT

  2. In Criteri di accesso condivisi fare clic sul criterio iothubowner, quindi copiare e annotare la stringa di connessione dell'hub IoT nella finestra iothubowner.In Shared access policies, click the iothubowner policy, and then copy and make note of the IoT Hub connection string in the iothubowner window. Per altre informazioni, vedere Controllo di accesso nella "Guida per gli sviluppatori dell'hub IoT".For more information, see Access control in the "IoT Hub developer guide."

    Criteri di accesso condivisi

Prendere infine nota del valore presente in Chiave primaria.As a final step, make a note of the Primary key value. Fare clic su Endpoint e sull'endpoint predefinito Eventi.Then click Endpoints and the Events built-in endpoint. Nel pannello Proprietà prendere nota del valore presente in Nome compatibile con l'hub eventi e dell'indirizzo Endpoint compatibile con l'hub eventi.On the Properties blade, make a note of the Event Hub-compatible name and the Event Hub-compatible endpoint address. Questi tre valori sono necessari quando si crea l'app read-d2c-messages.You need these three values when you create your read-d2c-messages app.

Pannello Messaggistica dell'hub IoT nel portale di Azure

L'hub IoT è stato creato.You have now created your IoT hub. Si conoscono il nome host dell'hub IoT, la stringa di connessione dell'hub IoT, la chiave primaria dell'hub IoT, il nome e l'endpoint compatibili con l'hub eventi necessari per completare l'esercitazione.You have the IoT Hub host name, IoT Hub connection string, IoT Hub Primary Key, Event Hub-compatible name, and Event Hub-compatible endpoint you need to complete this tutorial.

Creare un'identità del dispositivoCreate a device identity

In questa sezione si scriverà un'app console Java che crea un'identità del dispositivo nel registro delle identità dell'hub IoT.In this section, you create a Java console app that creates a device identity in the identity registry in your IoT hub. Un dispositivo non può connettersi all'hub IoT a meno che non abbia una voce nel registro di identità.A device cannot connect to IoT hub unless it has an entry in the identity registry. Per altre informazioni, vedere la sezione Registro di identità della Guida per gli sviluppatori dell'hub IoT.For more information, see the Identity Registry section of the IoT Hub developer guide. Quando si esegue questa app console vengono generati un ID dispositivo univoco e una chiave con cui il dispositivo può identificarsi quando invia messaggi da dispositivo a cloud all'hub IoT.When you run this console app, it generates a unique device ID and key that your device can use to identify itself when it sends device-to-cloud messages to IoT Hub.

  1. Creare una cartella vuota denominata iot-java-get-started.Create an empty folder called iot-java-get-started. Nella cartella iot-java-get-started creare un progetto Maven denominato create-device-identity usando il comando seguente al prompt dei comandi.In the iot-java-get-started folder, create a Maven project called create-device-identity using the following command at your command prompt. Si noti che si tratta di un lungo comando singolo:Note this is a single, long command:

    mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=create-device-identity -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
    
  2. Al prompt dei comandi passare alla cartella create-device-identity.At your command prompt, navigate to the create-device-identity folder.

  3. In un editor di testo aprire il file pom.xml nella cartella create-device-identity e aggiungere la dipendenza seguente al nodo dependencies .Using a text editor, open the pom.xml file in the create-device-identity folder and add the following dependency to the dependencies node. Questa dipendenza consente di usare il pacchetto iot-service-client nell'app:This dependency enables you to use the iot-service-client package in your app:

    <dependency>
      <groupId>com.microsoft.azure.sdk.iot</groupId>
      <artifactId>iot-service-client</artifactId>
      <version>1.7.23</version>
    </dependency>
    

    Nota

    È possibile cercare la versione più recente di iot-service-client usando la ricerca di Maven.You can check for the latest version of iot-service-client using Maven search.

  4. Salvare e chiudere il file pom.xml.Save and close the pom.xml file.

  5. Usando un editor di testo, aprire il file create-device-identity\src\main\java\com\mycompany\app\App.java.Using a text editor, open the create-device-identity\src\main\java\com\mycompany\app\App.java file.

  6. Aggiungere al file le istruzioni import seguenti:Add the following import statements to the file:

    import com.microsoft.azure.sdk.iot.service.exceptions.IotHubException;
    import com.microsoft.azure.sdk.iot.service.Device;
    import com.microsoft.azure.sdk.iot.service.RegistryManager;
    
    import java.io.IOException;
    import java.net.URISyntaxException;
    
  7. Aggiungere le variabili a livello di classe seguenti alla classe App, sostituendo {yourhubconnectionstring} con i valori annotati prima:Add the following class-level variables to the App class, replacing {yourhubconnectionstring} with the value your noted earlier:

    private static final String connectionString = "{yourhubconnectionstring}";
    private static final String deviceId = "myFirstJavaDevice";
    

    Importante

    L'ID dispositivo può essere visibile nei log raccolti per il supporto tecnico e la risoluzione dei problemi, quindi evitare di indicare informazioni riservate nell'assegnazione del nome.The device ID may be visible in the logs collected for customer support and troubleshooting, so make sure to avoid any sensitive information while naming it.

  8. Modificare la firma del metodo main includendo le eccezioni come segue:Modify the signature of the main method to include the exceptions as follows:

    public static void main( String[] args ) throws IOException, URISyntaxException, Exception
    
  9. Aggiungere il codice seguente come corpo del metodo main .Add the following code as the body of the main method. Questo codice crea un dispositivo denominato javadevice nel registro delle identità dell'hub IoT, se non esiste già.This code creates a device called javadevice in your IoT Hub identity registry if doesn't already exist. Quindi visualizza l'ID e la chiave del dispositivo che serviranno più avanti:It then displays the device ID and key that you need later:

    RegistryManager registryManager = RegistryManager.createFromConnectionString(connectionString);
    
    // Create a device that's enabled by default, 
    // with an autogenerated key.
    Device device = Device.createFromId(deviceId, null, null);
    try {
      device = registryManager.addDevice(device);
    } catch (IotHubException iote) {
      // If the device already exists.
      try {
        device = registryManager.getDevice(deviceId);
      } catch (IotHubException iotf) {
        iotf.printStackTrace();
      }
    }
    
    // Display information about the
    // device you created.
    System.out.println("Device Id: " + device.getDeviceId());
    System.out.println("Device key: " + device.getPrimaryKey());
    
  10. Salvare e chiudere il file App.java.Save and close the App.java file.

  11. Per compilare l'app create-device-identity con Maven, eseguire il comando seguente al prompt dei comandi nella cartella create-device-identity:To build the create-device-identity app using Maven, execute the following command at the command prompt in the create-device-identity folder:

    mvn clean package -DskipTests
    
  12. Per eseguire l'app create-device-identity con Maven, eseguire il comando seguente al prompt dei comandi nella cartella create-device-identity:To run the create-device-identity app using Maven, execute the following command at the command prompt in the create-device-identity folder:

    mvn exec:java -Dexec.mainClass="com.mycompany.app.App"
    
  13. Prendere nota dei valori di Device ID e Device key,Make a note of the Device ID and Device key. che saranno necessari più avanti quando si crea un'app che si connette all'hub IoT come dispositivo.You need these values later when you create an app that connects to IoT Hub as a device.

Nota

Il registro di identità dell'hub IoT archivia solo le identità del dispositivo per abilitare l'accesso sicuro all'hub.The IoT Hub identity registry only stores device identities to enable secure access to the IoT hub. Archivia le chiavi e gli ID dispositivo da usare come credenziali di sicurezza e un flag di abilitazione/disabilitazione che consente di disabilitare l'accesso per un singolo dispositivo.It stores device IDs and keys to use as security credentials and an enabled/disabled flag that you can use to disable access for an individual device. Se l'app deve archiviare altri metadati specifici del dispositivo, dovrà usare un'archiviazione specifica per app.If your app needs to store other device-specific metadata, it should use an app-specific store. Per altre informazioni, vedere la Guida per gli sviluppatori dell'hub IoT.For more information, see the IoT Hub developer guide.

Ricezione di messaggi da dispositivo a cloudReceive device-to-cloud messages

In questa sezione si crea un'app console di Java che legge i messaggi da dispositivo a cloud dall'hub IoT.In this section, you create a Java console app that reads device-to-cloud messages from IoT Hub. Un hub IoT espone un endpoint compatibile con l'hub eventi per abilitare la lettura dei messaggi dispositivo a cloud.An IoT hub exposes an Event Hub-compatible endpoint to enable you to read device-to-cloud messages. Per semplicità, questa esercitazione crea un lettore di base non adatto per una distribuzione con velocità effettiva elevata.To keep things simple, this tutorial creates a basic reader that is not suitable for a high throughput deployment. L'esercitazione Elaborare messaggi dispositivo a cloud illustra come elaborare i messaggi dispositivo a cloud su vasta scala.The Process device-to-cloud messages tutorial shows you how to process device-to-cloud messages at scale. L'esercitazione Introduzione all'hub eventi offre altre informazioni su come elaborare i messaggi da hub eventi ed è applicabile agli endpoint compatibili con l'hub eventi dell'hub IoT.The Get Started with Event Hubs tutorial provides further information on how to process messages from Event Hubs and is applicable to the IoT Hub Event Hub-compatible endpoints.

Nota

L'endpoint compatibile con Hub eventi per la lettura di messaggi da dispositivo a cloud usa sempre il protocollo AMQP.The Event Hub-compatible endpoint for reading device-to-cloud messages always uses the AMQP protocol.

  1. Nella cartella iot-java-get-started creata nella sezione Creare un'identità del dispositivo creare un progetto Maven denominato read-d2c-messages usando il comando seguente al prompt dei comandi.In the iot-java-get-started folder you created in the Create a device identity section, create a Maven project called read-d2c-messages using the following command at your command prompt. Si noti che si tratta di un lungo comando singolo:Note this is a single, long command:

    mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=read-d2c-messages -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
    
  2. Al prompt dei comandi passare alla cartella read-d2c-messages.At your command prompt, navigate to the read-d2c-messages folder.

  3. In un editor di testo aprire il file pom.xml nella cartella read-d2c-messages e aggiungere la dipendenza seguente al nodo dependencies .Using a text editor, open the pom.xml file in the read-d2c-messages folder and add the following dependency to the dependencies node. Questa dipendenza consente di usare il pacchetto eventhubs-client nell'app per la lettura dall'endpoint compatibile con l'hub eventi:This dependency enables you to use the eventhubs-client package in your app to read from the Event Hub-compatible endpoint:

    <dependency> 
        <groupId>com.microsoft.azure</groupId> 
        <artifactId>azure-eventhubs</artifactId> 
        <version>0.15.0</version> 
    </dependency>
    
  4. Salvare e chiudere il file pom.xml.Save and close the pom.xml file.

  5. Usando un editor di testo, aprire il file read-d2c-messages\src\main\java\com\mycompany\app\App.java.Using a text editor, open the read-d2c-messages\src\main\java\com\mycompany\app\App.java file.

  6. Aggiungere al file le istruzioni import seguenti:Add the following import statements to the file:

    import java.io.IOException;
    import com.microsoft.azure.eventhubs.*;
    
    import java.nio.charset.Charset;
    import java.time.*;
    import java.util.function.*;
    
  7. Aggiungere la variabili a livello di classe seguente alla classe App .Add the following class-level variable to the App class. Sostituire {youriothubkey}, {youreventhubcompatibleendpoint} e {youreventhubcompatiblename} con i valori annotati in precedenza:Replace {youriothubkey}, {youreventhubcompatibleendpoint}, and {youreventhubcompatiblename} with the values you noted previously:

    private static String connStr = "Endpoint={youreventhubcompatibleendpoint};EntityPath={youreventhubcompatiblename};SharedAccessKeyName=iothubowner;SharedAccessKey={youriothubkey}";
    
  8. Aggiungere il metodo receiveMessages seguente alla classe App.Add the following receiveMessages method to the App class. Questo metodo crea un'istanza EventHubClient per connettersi all'endpoint compatibile con Hub eventi e quindi crea in modo asincrono un'istanza PartitionReceiver per la lettura da una partizione di Hub eventi.This method creates an EventHubClient instance to connect to the Event Hub-compatible endpoint and then asynchronously creates a PartitionReceiver instance to read from an Event Hub partition. Esegue il ciclo ininterrottamente e stampa i dettagli del messaggio finché l'applicazione non termina.It loops continuously and prints the message details until the app terminates.

    // Create a receiver on a partition.
    private static EventHubClient receiveMessages(final String partitionId) {
      EventHubClient client = null;
      try {
        client = EventHubClient.createFromConnectionStringSync(connStr);
      } catch (Exception e) {
        System.out.println("Failed to create client: " + e.getMessage());
        System.exit(1);
      }
      try {
        // Create a receiver using the
        // default Event Hubs consumer group
        // that listens for messages from now on.
        client.createReceiver(EventHubClient.DEFAULT_CONSUMER_GROUP_NAME, partitionId, Instant.now())
          .thenAccept(new Consumer<PartitionReceiver>() {
            public void accept(PartitionReceiver receiver) {
              System.out.println("** Created receiver on partition " + partitionId);
              try {
                while (true) {
                  Iterable<EventData> receivedEvents = receiver.receive(100).get();
                  int batchSize = 0;
                  if (receivedEvents != null) {
                    System.out.println("Got some evenst");
                    for (EventData receivedEvent : receivedEvents) {
                      System.out.println(String.format("Offset: %s, SeqNo: %s, EnqueueTime: %s",
                        receivedEvent.getSystemProperties().getOffset(),
                        receivedEvent.getSystemProperties().getSequenceNumber(),
                        receivedEvent.getSystemProperties().getEnqueuedTime()));
                      System.out.println(String.format("| Device ID: %s",
                        receivedEvent.getSystemProperties().get("iothub-connection-device-id")));
                      System.out.println(String.format("| Message Payload: %s",
                        new String(receivedEvent.getBytes(), Charset.defaultCharset())));
                      batchSize++;
                    }
                  }
                  System.out.println(String.format("Partition: %s, ReceivedBatch Size: %s", partitionId, batchSize));
                }
              } catch (Exception e) {
                System.out.println("Failed to receive messages: " + e.getMessage());
              }
            }
          });
        } catch (Exception e) {
          System.out.println("Failed to create receiver: " + e.getMessage());
      }
      return client;
    }
    

    Nota

    Questo metodo usa un filtro quando crea il ricevitore e quindi il ricevitore legge solo i messaggi inviati all'hub IoT dopo che l'esecuzione del ricevitore è iniziata.This method uses a filter when it creates the receiver so that the receiver only reads messages sent to IoT Hub after the receiver starts running. Questa tecnica è utile in un ambiente di test perché consente di visualizzare il set di messaggi corrente.This technique is useful in a test environment so you can see the current set of messages. In un ambiente di produzione, il codice deve verificare di avere elaborato tutti i messaggi. Per altre informazioni, vedere l'esercitazione Elaborare messaggi dispositivo a cloud dell'hub IoT.In a production environment, your code should make sure that it processes all the messages - for more information, see the How to process IoT Hub device-to-cloud messages tutorial.

  9. Modificare la firma del metodo main includendo l'eccezione come segue:Modify the signature of the main method to include the exception as follows:

    public static void main( String[] args ) throws IOException
    
  10. Aggiungere il codice seguente al metodo main nella classe App.Add the following code to the main method in the App class. Questo codice crea le due istanze EventHubClient e PartitionReceiver e consente di chiudere l'app al termine dell'elaborazione dei messaggi:This code creates the two EventHubClient and PartitionReceiver instances and enables you to close the app when you have finished processing messages:

    // Create receivers for partitions 0 and 1.
    EventHubClient client0 = receiveMessages("0");
    EventHubClient client1 = receiveMessages("1");
    System.out.println("Press ENTER to exit.");
    System.in.read();
    try {
      client0.closeSync();
      client1.closeSync();
      System.exit(0);
    } catch (Exception e) {
      System.exit(1);
    }
    

    Nota

    Questo codice presuppone che l'hub IoT sia stato creato nel livello F1 gratuito.This code assumes you created your IoT hub in the F1 (free) tier. Un hub IoT gratuito ha due partizioni denominate "0" e "1".A free IoT hub has two partitions named "0" and "1".

  11. Salvare e chiudere il file App.java.Save and close the App.java file.

  12. Per compilare l'app read-d2c-messages con Maven, eseguire questo comando al prompt dei comandi nella cartella read-d2c-messages:To build the read-d2c-messages app using Maven, execute the following command at the command prompt in the read-d2c-messages folder:

    mvn clean package -DskipTests
    

Creare un'app per dispositiviCreate a device app

In questa sezione si crea un'app console di Java che simula un dispositivo che invia messaggi da dispositivo a cloud a un hub IoT.In this section, you create a Java console app that simulates a device that sends device-to-cloud messages to an IoT hub.

  1. Nella cartella iot-java-get-started creata nella sezione Creare un'identità del dispositivo creare un progetto Maven denominato simulated-device usando il comando seguente al prompt dei comandi.In the iot-java-get-started folder you created in the Create a device identity section, create a Maven project called simulated-device using the following command at your command prompt. Si noti che si tratta di un lungo comando singolo:Note this is a single, long command:

    mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=simulated-device -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
    
  2. Al prompt dei comandi passare alla cartella simulated-device.At your command prompt, navigate to the simulated-device folder.

  3. In un editor di testo aprire il file pom.xml nella cartella simulated-device e aggiungere le dipendenze seguenti al nodo dependencies .Using a text editor, open the pom.xml file in the simulated-device folder and add the following dependencies to the dependencies node. Queste dipendenze consentono di usare il pacchetto iothub-java-client nell'app per comunicare con l'hub IoT e per serializzare gli oggetti Java in JSON:This dependency enables you to use the iothub-java-client package in your app to communicate with your IoT hub and to serialize Java objects to JSON:

    <dependency>
      <groupId>com.microsoft.azure.sdk.iot</groupId>
      <artifactId>iot-device-client</artifactId>
      <version>1.3.32</version>
    </dependency>
    <dependency>
      <groupId>com.google.code.gson</groupId>
      <artifactId>gson</artifactId>
      <version>2.3.1</version>
    </dependency>
    

    Nota

    È possibile cercare la versione più recente di iot-device-client usando la ricerca di Maven.You can check for the latest version of iot-device-client using Maven search.

  4. Salvare e chiudere il file pom.xml.Save and close the pom.xml file.

  5. Usando un editor di testo, aprire il file simulated-device\src\main\java\com\mycompany\app\App.java.Using a text editor, open the simulated-device\src\main\java\com\mycompany\app\App.java file.

  6. Aggiungere al file le istruzioni import seguenti:Add the following import statements to the file:

    import com.microsoft.azure.sdk.iot.device.*;
    import com.google.gson.Gson;
    
    import java.io.*;
    import java.net.URISyntaxException;
    import java.util.Random;
    import java.util.concurrent.Executors;
    import java.util.concurrent.ExecutorService;
    
  7. Aggiungere le variabili a livello di classe seguenti alla classe App .Add the following class-level variables to the App class. Sostituzione di {youriothubname} con il nome dell'hub IoT e di {yourdevicekey} con il valore della chiave del dispositivo generato nella sezione Creare un'identità del dispositivo:Replacing {youriothubname} with your IoT hub name, and {yourdevicekey} with the device key value you generated in the Create a device identity section:

    private static String connString = "HostName={youriothubname}.azure-devices.net;DeviceId=myFirstJavaDevice;SharedAccessKey={yourdevicekey}";
    private static IotHubClientProtocol protocol = IotHubClientProtocol.MQTT;
    private static String deviceId = "myFirstJavaDevice";
    private static DeviceClient client;
    

    Questa app di esempio usa la variabile protocol quando crea un'istanza di un oggetto DeviceClient.This sample app uses the protocol variable when it instantiates a DeviceClient object. È possibile usare il protocollo MQTT, AMQP o HTTPS per comunicare con l'hub IoT.You can use either the MQTT, AMQP, or HTTPS protocol to communicate with IoT Hub.

  8. Aggiungere la classe TelemetryDataPoint annidata seguente nella classe App per specificare i dati di telemetria inviati dal dispositivo all'hub IoT:Add the following nested TelemetryDataPoint class inside the App class to specify the telemetry data your device sends to your IoT hub:

    private static class TelemetryDataPoint {
      public String deviceId;
      public double temperature;
      public double humidity;
    
      public String serialize() {
        Gson gson = new Gson();
        return gson.toJson(this);
      }
    }
    
  9. Aggiungere la classe EventCallback annidata seguente nella classe App per visualizzare lo stato di acknowledgement restituito dall'hub IoT quando elabora un messaggio proveniente dall'app per dispositivi.Add the following nested EventCallback class inside the App class to display the acknowledgement status that the IoT hub returns when it processes a message from the device app. Questo metodo invia anche una notifica al thread principale dell'app quando il messaggio è stato elaborato:This method also notifies the main thread in the app when the message has been processed:

    private static class EventCallback implements IotHubEventCallback {
      public void execute(IotHubStatusCode status, Object context) {
        System.out.println("IoT Hub responded to message with status: " + status.name());
    
        if (context != null) {
          synchronized (context) {
            context.notify();
          }
        }
      }
    }
    
  10. Aggiungere la classe MessageSender annidata seguente nella classe App.Add the following nested MessageSender class inside the App class. Il metodo run in questa classe genera dati di telemetria di esempio da inviare all'hub IoT e attende un acknowledgement prima di inviare il messaggio successivo:The run method in this class generates sample telemetry data to send to your IoT hub and waits for an acknowledgement before sending the next message:

    private static class MessageSender implements Runnable {
      public void run()  {
        try {
          double minTemperature = 20;
          double minHumidity = 60;
          Random rand = new Random();
    
          while (true) {
            double currentTemperature = minTemperature + rand.nextDouble() * 15;
            double currentHumidity = minHumidity + rand.nextDouble() * 20;
            TelemetryDataPoint telemetryDataPoint = new TelemetryDataPoint();
            telemetryDataPoint.deviceId = deviceId;
            telemetryDataPoint.temperature = currentTemperature;
            telemetryDataPoint.humidity = currentHumidity;
    
            String msgStr = telemetryDataPoint.serialize();
            Message msg = new Message(msgStr);
            msg.setProperty("temperatureAlert", (currentTemperature > 30) ? "true" : "false");
            msg.setMessageId(java.util.UUID.randomUUID().toString()); 
            System.out.println("Sending: " + msgStr);
    
            Object lockobj = new Object();
            EventCallback callback = new EventCallback();
            client.sendEventAsync(msg, callback, lockobj);
    
            synchronized (lockobj) {
              lockobj.wait();
            }
            Thread.sleep(1000);
          }
        } catch (InterruptedException e) {
          System.out.println("Finished.");
        }
      }
    }
    

    Questo metodo invia un nuovo messaggio da dispositivo a cloud un secondo dopo che l'hub IoT ha riconosciuto il messaggio precedente.This method sends a new device-to-cloud message one second after the IoT hub acknowledges the previous message. Il messaggio contiene un oggetto serializzato JSON con l'ID dispositivo e numeri generati casualmente per simulare un sensore temperatura e un sensore umidità.The message contains a JSON-serialized object with the deviceId and randomly generated numbers to simulate a temperature sensor, and a humidity sensor.

  11. Sostituire il metodo main con il codice seguente che crea un thread per inviare messaggi da dispositivo a cloud all'hub IoT:Replace the main method with the following code that creates a thread to send device-to-cloud messages to your IoT hub:

    public static void main( String[] args ) throws IOException, URISyntaxException {
      client = new DeviceClient(connString, protocol);
      client.open();
    
      MessageSender sender = new MessageSender();
    
      ExecutorService executor = Executors.newFixedThreadPool(1);
      executor.execute(sender);
    
      System.out.println("Press ENTER to exit.");
      System.in.read();
      executor.shutdownNow();
      client.closeNow();
    }
    
  12. Salvare e chiudere il file App.java.Save and close the App.java file.

  13. Per compilare l'app simulated-device con Maven, eseguire questo comando al prompt dei comandi nella cartella simulated-device:To build the simulated-device app using Maven, execute the following command at the command prompt in the simulated-device folder:

    mvn clean package -DskipTests
    

Nota

Per semplicità, in questa esercitazione non si implementa alcun criterio di ripetizione dei tentativi.To keep things simple, this tutorial does not implement any retry policy. Nel codice di produzione è consigliabile implementare criteri per i tentativi, ad esempio un backoff esponenziale, come illustrato nell'articolo di MSDN Transient Fault Handling (Gestione degli errori temporanei).In production code, you should implement retry policies (such as an exponential backoff), as suggested in the MSDN article Transient Fault Handling.

Eseguire le appRun the apps

A questo punto è possibile eseguire le app.You are now ready to run the apps.

  1. Al prompt dei comandi nella cartella read-d2c eseguire questo comando per iniziare a monitorare la prima partizione dell'hub IoT:At a command prompt in the read-d2c folder, run the following command to begin monitoring the first partition in your IoT hub:

    mvn exec:java -Dexec.mainClass="com.mycompany.app.App"
    

    App del servizio hub IoT per Java per monitorare i messaggi dispositivo a cloud

  2. Al prompt dei comandi nella cartella simulated-device eseguire il comando seguente per iniziare a inviare i dati di telemetria all'hub IoT:At a command prompt in the simulated-device folder, run the following command to begin sending telemetry data to your IoT hub:

    mvn exec:java -Dexec.mainClass="com.mycompany.app.App" 
    

    App del dispositivo hub IoT per Java per inviare i messaggi da dispositivo a cloud

  3. Il riquadro Utilizzo nel portale di Azure mostra il numero di messaggi inviati all'hub IoT:The Usage tile in the Azure portal shows the number of messages sent to the IoT hub:

    Riquadro Utilizzo del portale di Azure con il numero dei messaggi inviati all'hub IoT

Passaggi successiviNext steps

In questa esercitazione è stato configurato un nuovo hub IoT nel Portale di Azure ed è stata quindi creata un'identità del dispositivo nel registro di identità dell'hub IoT.In this tutorial, you configured a new IoT hub in the Azure portal, and then created a device identity in the IoT hub's identity registry. Questa identità del dispositivo è stata usata per consentire all'app per dispositivi di inviare messaggi da dispositivo a cloud all'hub IoT.You used this device identity to enable the device app to send device-to-cloud messages to the IoT hub. È stata anche creata un'app che visualizza i messaggi ricevuti dall'hub IoT.You also created an app that displays the messages received by the IoT hub.

Per altre informazioni sulle attività iniziali con l'hub IoT e per esplorare altri scenari IoT, vedere:To continue getting started with IoT Hub and to explore other IoT scenarios, see:

Per informazioni sull'estensione della soluzione IoT e l'elaborazione di messaggi dispositivo a cloud su vasta scala, vedere l'esercitazione Elaborare messaggi dispositivo a cloud.To learn how to extend your IoT solution and process device-to-cloud messages at scale, see the Process device-to-cloud messages tutorial.

Per altre informazioni sulle attività iniziali con l'hub IoT di Azure e per esplorare altri scenari IoT, vedere:To continue to get started with Azure IoT Hub and to explore other IoT scenarios, see the following: