Pianificare e trasmettere processi (Java)Schedule and broadcast jobs (Java)

Usare l'hub IoT per pianificare e tenere traccia dei processi che aggiornano milioni di dispositivi.Use Azure IoT Hub to schedule and track jobs that update millions of devices. Usare i processi per:Use jobs to:

  • Aggiornare le proprietà desiderateUpdate desired properties
  • Aggiornare i tagUpdate tags
  • Richiamare metodi direttiInvoke direct methods

Un processo esegue il wrapping di una di queste azioni e tiene traccia dell'esecuzione rispetto a un set di dispositivi.A job wraps one of these actions and tracks the execution against a set of devices. Una query di dispositivi gemelli definisce il set di dispositivi su cui il processo viene eseguito.A device twin query defines the set of devices the job executes against. Ad esempio, un'applicazione back-end può usare un processo per chiamare un metodo diretto su 10.000 dispositivi che riavvia i dispositivi stessi.For example, a back-end app can use a job to invoke a direct method on 10,000 devices that reboots the devices. È necessario specificare il set di dispositivi con una query di dispositivi gemelli e pianificare il processo in modo che venga eseguito in un secondo momento.You specify the set of devices with a device twin query and schedule the job to run at a future time. L'applicazione può quindi tenere traccia dell'avanzamento mentre ognuno dei dispositivi riceve ed esegue il metodo diretto di riavvio.The job tracks progress as each of the devices receive and execute the reboot direct method.

Per altre informazioni su queste funzionalità, vedere:To learn more about each of these capabilities, see:

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

  • Creare un'app per dispositivi che implementa un metodo diretto denominato lockDoor.Create a device app that implements a direct method called lockDoor. L'app per dispositivi riceve anche le modifiche di proprietà desiderate dall'app back-end.The device app also receives desired property changes from the back-end app.
  • Creare un'app back-end che crea un processo per chiamare il metodo diretto lockDoor su più dispositivi.Create a back-end app that creates a job to call the lockDoor direct method on multiple devices. Un altro processo invia gli aggiornamenti di proprietà desiderati a più dispositivi.Another job sends desired property updates to multiple devices.

Al termine dell'esercitazione saranno disponibili un'app per il dispositivo console Java e un'app back-end console Java:At the end of this tutorial, you have a java console device app and a java console back-end app:

simulated-device che si connette all'hub IoT, implementa il metodo diretto lockDoor e gestisce le modifiche di proprietà desiderate.simulated-device that connects to your IoT hub, implements the lockDoor direct method, and handles desired property changes.

schedule-jobs che usa processi per chiamare il metodo diretto lockDoor e aggiornare le proprietà di dispositivi gemelli desiderate su più dispositivi.schedule-jobs that use jobs to call the lockDoor direct method and update the device twin desired properties on multiple devices.

Nota

L'articolo Azure IoT SDK riporta informazioni sui componenti Azure IoT SDK che consentono di compilare le app back-end e per dispositivi.The article Azure IoT SDKs provides information about the Azure IoT SDKs that you can use to build both device and back-end apps.

PrerequisitiPrerequisites

Per completare questa esercitazione, sono necessari:To complete this tutorial, you need:

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

Creare un'identità del dispositivoCreate a device identity

In questa sezione si usa il portale di Azure per creare un'identità del dispositivo nel registro delle identità dell'hub IoT.In this section, you use the Azure portal to create 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. Nel portale, Device Explorer consente di generare una chiave e un ID dispositivo univoci con cui il dispositivo può identificarsi quando si connette all'hub IoT.The Device Explorer in the portal helps you generate a unique device ID and key that your device can use to identify itself when it connects to IoT Hub. Gli ID dispositivo fanno distinzione tra maiuscole e minuscole.Device IDs are case sensitive.

  1. Assicurarsi di aver eseguito l'accesso al portale di Azure.Make sure you are signed in to the Azure portal.

  2. Nell'indice fare clic su Tutte le risorse e trovare la risorsa hub IoT.In the Jumpbar, click All resources and find your IoT hub resource.

    Passare all'hub IoT

  3. Dopo aver aperto la risorsa hub IoT, fare clic sullo strumento Device Explorer e quindi su Aggiungi nella parte superiore.When your IoT hub resource is opened, click the Device Explorer tool, and then click Add at the top. Specificare un nome per il nuovo dispositivo, ad esempio myDeviceId e fare clic su Salva.Provide the name for your new device, such as myDeviceId, and click Save.

    Creare l'identità del dispositivo nel portale

    In questo modo viene creata una nuova identità del dispositivo per l'hub IoT.This creates a new device identity for your IoT hub.

    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.

  4. Nell'elenco dei dispositivi in Device Explorer fare clic sul dispositivo appena creato e prendere nota della Stringa di connessione - chiave primaria.In the Device Explorer's device list, click the newly created device and make note of the Connection string---primary key.

    Stringa di connessione del dispositivo

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 gli ID dispositivo e le chiavi da usare come credenziali di sicurezza e un flag di attivazione/disattivazione 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'applicazione deve archiviare altri metadati specifici del dispositivo, dovrà usare un archivio specifico dell'applicazione.If your application needs to store other device-specific metadata, it should use an application-specific store. Per altre informazioni, vedere la Guida per gli sviluppatori dell'hub IoT.For more information, see IoT Hub developer guide.

Se si preferisce creare l'identità del dispositivo a livello di programmazione, leggere la sezione corrispondente nell'articolo Connettere il dispositivo all'hub IoT usando Java.If you prefer to create the device identity programmatically, read the corresponding section in the Connect your device to your IoT hub using Java article. È possibile anche usare lo strumento iothub-explorer per aggiungere un dispositivo all'hub IoT.You can also use the iothub-explorer tool to add a device to your IoT hub.

Creare l'app di servizioCreate the service app

In questa sezione si crea un'app console Java che usa i processi per:In this section, you create a Java console app that uses jobs to:

  • Chiamare il metodo diretto lockDoor su più dispositivi.Call the lockDoor direct method on multiple devices.
  • Inviare le proprietà desiderate a più dispositivi.Send desired properties to multiple devices.

Per creare l'app:To create the app:

  1. Nel computer di sviluppo creare una cartella vuota denominata iot-java-schedule-jobs.On your development machine, create an empty folder called iot-java-schedule-jobs.

  2. Nella cartella iot-java-schedule-jobs creare un progetto Maven denominato schedule-jobs eseguendo il comando seguente al prompt dei comandi.In the iot-java-schedule-jobs folder, create a Maven project called schedule-jobs 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=schedule-jobs -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

  3. Al prompt dei comandi passare alla cartella schedule-jobs.At your command prompt, navigate to the schedule-jobs folder.

  4. In un editor di testo aprire il file pom.xml nella cartella schedule-jobs e aggiungere la dipendenza seguente al nodo dependencies.Using a text editor, open the pom.xml file in the schedule-jobs folder and add the following dependency to the dependencies node. Questa dipendenza consente di usare il pacchetto iot-service-client nell'app per comunicare con l'hub IoT:This dependency enables you to use the iot-service-client package in your app to communicate with your IoT hub:

    <dependency>
      <groupId>com.microsoft.azure.sdk.iot</groupId>
      <artifactId>iot-service-client</artifactId>
      <version>1.7.23</version>
      <type>jar</type>
    </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.

  5. Aggiungere il nodo build seguente dopo il nodo dependencies.Add the following build node after the dependencies node. Questa configurazione indica a Maven di usare Java 1.8 per compilare l'app:This configuration instructs Maven to use Java 1.8 to build the app:

    <build>
      <plugins>
        <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.3</version>
          <configuration>
            <source>1.8</source>
            <target>1.8</target>
          </configuration>
        </plugin>
      </plugins>
    </build>
    
  6. Salvare e chiudere il file pom.xml.Save and close the pom.xml file.

  7. Aprire il file schedule-jobs\src\main\java\com\mycompany\app\App.java in un editor di testo.Using a text editor, open the schedule-jobs\src\main\java\com\mycompany\app\App.java file.

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

    import com.microsoft.azure.sdk.iot.service.devicetwin.DeviceTwinDevice;
    import com.microsoft.azure.sdk.iot.service.devicetwin.Pair;
    import com.microsoft.azure.sdk.iot.service.devicetwin.Query;
    import com.microsoft.azure.sdk.iot.service.devicetwin.SqlQuery;
    import com.microsoft.azure.sdk.iot.service.jobs.JobClient;
    import com.microsoft.azure.sdk.iot.service.jobs.JobResult;
    import com.microsoft.azure.sdk.iot.service.jobs.JobStatus;
    
    import java.util.Date;
    import java.time.Instant;
    import java.util.HashSet;
    import java.util.Set;
    import java.util.UUID;
    
  9. Aggiungere le variabili a livello di classe seguenti alla classe App .Add the following class-level variables to the App class. Sostituire {youriothubconnectionstring} con la stringa di connessione dell'hub IoT indicata nella sezione Creare un hub IoT:Replace {youriothubconnectionstring} with your IoT hub connection string you noted in the Create an IoT Hub section:

    public static final String iotHubConnectionString = "{youriothubconnectionstring}";
    public static final String deviceId = "myDeviceId";
    
    // How long the job is permitted to run without
    // completing its work on the set of devices
    private static final long maxExecutionTimeInSeconds = 30;
    
  10. Aggiungere il metodo seguente alla classe App per pianificare un processo con cui aggiornare le proprietà desiderate di Building e Floor nel dispositivo gemello:Add the following method to the App class to schedule a job to update the Building and Floor desired properties in the device twin:

    private static JobResult scheduleJobSetDesiredProperties(JobClient jobClient, String jobId) {
      DeviceTwinDevice twin = new DeviceTwinDevice(deviceId);
      Set<Pair> desiredProperties = new HashSet<Pair>();
      desiredProperties.add(new Pair("Building", 43));
      desiredProperties.add(new Pair("Floor", 3));
      twin.setDesiredProperties(desiredProperties);
      // Optimistic concurrency control
      twin.setETag("*");
    
      // Schedule the update twin job to run now
      // against a single device
      System.out.println("Schedule job " + jobId + " for device " + deviceId);
      try {
        JobResult jobResult = jobClient.scheduleUpdateTwin(jobId, 
          "deviceId='" + deviceId + "'",
          twin,
          new Date(),
          maxExecutionTimeInSeconds);
        return jobResult;
      } catch (Exception e) {
        System.out.println("Exception scheduling desired properties job: " + jobId);
        System.out.println(e.getMessage());
        return null;
      }
    }
    
  11. Per pianificare un processo che chiama il metodo lockDoor, aggiungere il metodo seguente alla classe App:To schedule a job to call the lockDoor method, add the following method to the App class:

    private static JobResult scheduleJobCallDirectMethod(JobClient jobClient, String jobId) {
      // Schedule a job now to call the lockDoor direct method
      // against a single device. Response and connection
      // timeouts are set to 5 seconds.
      System.out.println("Schedule job " + jobId + " for device " + deviceId);
      try {
        JobResult jobResult = jobClient.scheduleDeviceMethod(jobId,
          "deviceId='" + deviceId + "'",
          "lockDoor",
          5L, 5L, null,
          new Date(),
          maxExecutionTimeInSeconds);
        return jobResult;
      } catch (Exception e) {
        System.out.println("Exception scheduling direct method job: " + jobId);
        System.out.println(e.getMessage());
        return null;
      }
    };
    
  12. Per monitorare un processo, aggiungere il metodo seguente alla classe App:To monitor a job, add the following method to the App class:

    private static void monitorJob(JobClient jobClient, String jobId) {
      try {
        JobResult jobResult = jobClient.getJob(jobId);
        if(jobResult == null)
        {
          System.out.println("No JobResult for: " + jobId);
          return;
        }
        // Check the job result until it's completed
        while(jobResult.getJobStatus() != JobStatus.completed)
        {
          Thread.sleep(100);
          jobResult = jobClient.getJob(jobId);
          System.out.println("Status " + jobResult.getJobStatus() + " for job " + jobId);
        }
        System.out.println("Final status " + jobResult.getJobStatus() + " for job " + jobId);
      } catch (Exception e) {
        System.out.println("Exception monitoring job: " + jobId);
        System.out.println(e.getMessage());
        return;
      }
    }
    
  13. Per eseguire una query sui dettagli dei processi eseguiti, aggiungere il metodo seguente:To query for the details of the jobs you ran, add the following method:

    private static void queryDeviceJobs(JobClient jobClient, String start) throws Exception {
      System.out.println("\nQuery device jobs since " + start);
    
      // Create a jobs query using the time the jobs started
      Query deviceJobQuery = jobClient
          .queryDeviceJob(SqlQuery.createSqlQuery("*", SqlQuery.FromType.JOBS, "devices.jobs.startTimeUtc > '" + start + "'", null).getQuery());
    
      // Iterate over the list of jobs and print the details
      while (jobClient.hasNextJob(deviceJobQuery)) {
        System.out.println(jobClient.getNextJob(deviceJobQuery));
      }
    }
    
  14. Aggiornare la firma del metodo main affinché includa la clausola throws:Update the main method signature to include the following throws clause:

    public static void main( String[] args ) throws Exception
    
  15. Per eseguire e monitorare due processi in sequenza, aggiungere il codice seguente al metodo main:To run and monitor two jobs sequentially, add the following code to the main method:

    // Record the start time
    String start = Instant.now().toString();
    
    // Create JobClient
    JobClient jobClient = JobClient.createFromConnectionString(iotHubConnectionString);
    System.out.println("JobClient created with success");
    
    // Schedule twin job desired properties
    // Maximum concurrent jobs is 1 for Free and S1 tiers
    String desiredPropertiesJobId = "DPCMD" + UUID.randomUUID();
    scheduleJobSetDesiredProperties(jobClient, desiredPropertiesJobId);
    monitorJob(jobClient, desiredPropertiesJobId);
    
    // Schedule twin job direct method
    String directMethodJobId = "DMCMD" + UUID.randomUUID();
    scheduleJobCallDirectMethod(jobClient, directMethodJobId);
    monitorJob(jobClient, directMethodJobId);
    
    // Run a query to show the job detail
    queryDeviceJobs(jobClient, start);
    
    System.out.println("Shutting down schedule-jobs app");
    
  16. Salvare e chiudere il file schedule-jobs\src\main\java\com\mycompany\app\App.javaSave and close the schedule-jobs\src\main\java\com\mycompany\app\App.java file

  17. Compilare l'app schedule-jobs e correggere eventuali errori.Build the schedule-jobs app and correct any errors. Al prompt dei comandi passare alla cartella schedule-jobs ed eseguire il comando seguente:At your command prompt, navigate to the schedule-jobs folder and run the following command:

    mvn clean package -DskipTests

Creare un'app per dispositiviCreate a device app

In questa sezione si crea un'app console Java che gestisce le proprietà desiderate inviate dall'hub IoT e implementa la chiamata di metodo diretto.In this section, you create a Java console app that handles the desired properties sent from IoT Hub and implements the direct method call.

  1. Nella cartella iot-java-schedule-jobs creare un progetto Maven denominato simulated-device usando il comando seguente al prompt dei comandi.In the iot-java-schedule-jobs folder, 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. Questa dipendenza consente di usare il pacchetto iot-device-client nell'app per comunicare con l'hub IoT:This dependency enables you to use the iot-device-client package in your app to communicate with your IoT hub:

    <dependency>
      <groupId>com.microsoft.azure.sdk.iot</groupId>
      <artifactId>iot-device-client</artifactId>
      <version>1.3.32</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. Aggiungere il nodo build seguente dopo il nodo dependencies.Add the following build node after the dependencies node. Questa configurazione indica a Maven di usare Java 1.8 per compilare l'app:This configuration instructs Maven to use Java 1.8 to build the app:

    <build>
      <plugins>
        <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.3</version>
          <configuration>
            <source>1.8</source>
            <target>1.8</target>
          </configuration>
        </plugin>
      </plugins>
    </build>
    
  5. Salvare e chiudere il file pom.xml.Save and close the pom.xml file.

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

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

    import com.microsoft.azure.sdk.iot.device.*;
    import com.microsoft.azure.sdk.iot.device.DeviceTwin.*;
    
    import java.io.IOException;
    import java.net.URISyntaxException;
    import java.util.Scanner;
    
  8. 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=myDeviceID;SharedAccessKey={yourdevicekey}";
    private static IotHubClientProtocol protocol = IotHubClientProtocol.MQTT;
    private static final int METHOD_SUCCESS = 200;
    private static final int METHOD_NOT_DEFINED = 404;
    

    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.

  9. Per stampare le notifiche del dispositivo gemello nella console, aggiungere la classe annidata seguente alla classe App:To print device twin notifications to the console, add the following nested class to the App class:

    // Handler for device twin operation notifications from IoT Hub
    protected static class DeviceTwinStatusCallBack implements IotHubEventCallback {
      public void execute(IotHubStatusCode status, Object context) {
        System.out.println("IoT Hub responded to device twin operation with status " + status.name());
      }
    }
    
  10. Per stampare le notifiche del metodo diretto nella console, aggiungere la classe annidata seguente alla classe App:To print direct method notifications to the console, add the following nested class to the App class:

    // Handler for direct method notifications from IoT Hub
    protected static class DirectMethodStatusCallback implements IotHubEventCallback {
      public void execute(IotHubStatusCode status, Object context) {
        System.out.println("IoT Hub responded to direct method operation with status " + status.name());
      }
    }
    
  11. Per gestire chiamate di metodo diretto dall'hub IoT, aggiungere la classe annidata seguente alla classe App:To handle direct method calls from IoT Hub, add the following nested class to the App class:

    // Handler for direct method calls from IoT Hub
    protected static class DirectMethodCallback
        implements DeviceMethodCallback {
      @Override
      public DeviceMethodData call(String methodName, Object methodData, Object context) {
        DeviceMethodData deviceMethodData;
        switch (methodName) {
          case "lockDoor": {
            System.out.println("Executing direct method: " + methodName);
            deviceMethodData = new DeviceMethodData(METHOD_SUCCESS, "Executed direct method " + methodName);
            break;
          }
          default: {
            deviceMethodData = new DeviceMethodData(METHOD_NOT_DEFINED, "Not defined direct method " + methodName);
          }
        }
        // Notify IoT Hub of result
        return deviceMethodData;
      }
    }
    
  12. Aggiornare la firma del metodo main affinché includa la clausola throws:Update the main method signature to include the following throws clause:

    public static void main( String[] args ) throws IOException, URISyntaxException
    
  13. Al metodo main aggiungere il codice seguente:Add the following code to the main method to:

    • Creare un client del dispositivo per comunicare con l'IoT Hub.Create a device client to communicate with IoT Hub.
    • Creare un oggetto Device per archiviare le proprietà dei dispositivi gemelli.Create a Device object to store the device twin properties.

      // Create a device client
      DeviceClient client = new DeviceClient(connString, protocol);
      
      // An object to manage device twin desired and reported properties
      Device dataCollector = new Device() {
      @Override
      public void PropertyCall(String propertyKey, Object propertyValue, Object context)
      {
        System.out.println("Received desired property change: " + propertyKey + " " + propertyValue);
      }
      };
      
  14. Per avviare i servizi client del dispositivo, aggiungere il codice seguente al metodo main:To start the device client services, add the following code to the main method:

    try {
      // Open the DeviceClient
      // Start the device twin services
      // Subscribe to direct method calls
      client.open();
      client.startDeviceTwin(new DeviceTwinStatusCallBack(), null, dataCollector, null);
      client.subscribeToDeviceMethod(new DirectMethodCallback(), null, new DirectMethodStatusCallback(), null);
    } catch (Exception e) {
      System.out.println("Exception, shutting down \n" + " Cause: " + e.getCause() + " \n" + e.getMessage());
      dataCollector.clean();
      client.closeNow();
      System.out.println("Shutting down...");
    }
    
  15. Per attendere che l'utente prema il tasto INVIO prima della chiusura, aggiungere il codice seguente alla fine del metodo main:To wait for the user to press the Enter key before shutting down, add the following code to the end of the main method:

    // Close the app
    System.out.println("Press any key to exit...");
    Scanner scanner = new Scanner(System.in);
    scanner.nextLine();
    dataCollector.clean();
    client.closeNow();
    scanner.close();
    
  16. Salvare e chiudere il file simulated-device\src\main\java\com\mycompany\app\App.java.Save and close the simulated-device\src\main\java\com\mycompany\app\App.java file.

  17. Compilare l'app simulated-device e correggere eventuali errori.Build the simulated-device app and correct any errors. Al prompt dei comandi passare alla cartella simulated-device ed eseguire il comando seguente:At your command prompt, navigate to the simulated-device folder and run the following command:

    mvn clean package -DskipTests

Eseguire le appRun the apps

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

  1. Al prompt dei comandi nella cartella simulated-device eseguire il comando seguente per avviare l'app per dispositivi che ascolta le modifiche di proprietà desiderate e le chiamate di metodo diretto:At a command prompt in the simulated-device folder, run the following command to start the device app listening for desired property changes and direct method calls:

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

    Il client per dispositivi si avvia

  2. Al prompt dei comandi nella cartella schedule-jobs eseguire il comando seguente per avviare l'app di servizio schedule-jobs in modo da eseguire due processi.At a command prompt in the schedule-jobs folder, run the following command to run the schedule-jobs service app to run two jobs. Il primo imposta i valori di proprietà desiderati, il secondo chiama il metodo diretto:The first sets the desired property values, the second calls the direct method:

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

    L'app di servizio dell'hub IoT Java crea due processi

  3. L'app per dispositivi gestisce la modifica di proprietà desiderata e la chiamata di metodo diretto:The device app handles the desired property change and the direct method call:

    Il client per dispositivi risponde alle modifiche

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. È stata creata un'app back-end per l'esecuzione di due processi.You created a back-end app to run two jobs. Il primo processo ha impostato i valori di proprietà desiderati e il secondo processo ha chiamato un metodo diretto.The first job set desired property values, and the second job called a direct method.

Per altre informazioni, vedere le risorse seguenti:Use the following resources to learn how to:

  • Per inviare dati di telemetria dai dispositivi, vedere l'esercitazione Introduzione all'hub IoT.Send telemetry from devices with the Get started with IoT Hub tutorial.
  • Per controllare i dispositivi in modo interattivo, ad esempio per attivare un ventilatore da un'app controllata dall'utente, vedere l'esercitazione Usare metodi diretti.Control devices interactively (such as turning on a fan from a user-controlled app) with the Use direct methods tutorial.