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:

Nota

Le funzionalità descritte in questo articolo sono disponibili solo nel livello Standard dell'hub IoT.The features described in this article are only available in the standard tier of IoT hub. Per altre informazioni sui livelli Basic e Standard dell'hub IoT, vedere come scegliere il livello corretto dell'hub IoT.For more information about the basic and standard IoT Hub tiers, see How to choose the right IoT Hub tier.

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 Crea una risorsa > Internet delle cose > Hub IoT.Select Create a resource > 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:

    • Sottoscrizione: scegliere la sottoscrizione da usare per creare questo hub IoT.Subscription: Choose the subscription that you want to use to create this IoT hub.

    • 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.

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

    • Nome: creare un nome per l'hub IoT.Name: Create a name for your IoT hub. Se il nome immesso è disponibile, viene visualizzato un segno di spunta verde.If the name you enter is available, 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.

    Finestra delle informazioni di base hub IoT

  4. Selezionare Next: Size and scale (Avanti: Dimensioni e scalabilità) per continuare a creare l'hub IoT.Select Next: Size and scale to continue creating your IoT hub.

  5. Scegliere un valore per Piano tariffario e livello di scalabilità.Choose your Pricing and scale tier. Per questo articolo selezionare il livello F1 - Gratuito se ancora disponibile nella sottoscrizione.For this article, select the F1 - Free tier if it's still available on your subscription. Per altre informazioni, vedere la pagina relativa a piano tariffario e livello di scalabilità.For more information, see the Pricing and scale tier.

    Finestra per specificare dimensioni e scalabilità dell'hub IoT

  6. Selezionare Rivedi e crea.Select Review + create.

  7. Esaminare le informazioni sull'hub IoT e quindi fare clic su Crea.Review your IoT hub information, then 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.

  8. Quando il nuovo hub IoT è pronto, fare clic sul suo riquadro nel portale di Azure per aprire la finestra delle proprietà.When your new IoT hub is ready, click its tile in the Azure portal to open its properties window. 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. Fare clic su Criteri di accesso condivisi.Click Shared access policies.

  9. In Criteri di accesso condivisi selezionare il criterio iothubowner.In Shared access policies, select the iothubowner policy. Copiare il valore di Stringa di connessione---Chiave primaria dell'hub IoT per usarlo in seguito.Copy the IoT Hub Connection string---primary key to use later. 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. Usare il pannello Dispositivi IoT nel portale per generare un ID dispositivo e una chiave univoci per il dispositivo per consentirne l'identificazione nell'hub IoT.Use the IoT Devices panel in the portal to generate a unique device ID and key for your device to use to identify itself to IoT Hub. Gli ID dispositivo fanno distinzione tra maiuscole e minuscole.Device IDs are case-sensitive.

  1. Accedere al portale di Azure.Sign in to the Azure portal.

  2. Selezionare Tutte le risorse e trovare la risorsa hub IoT.Select All resources and find your IoT hub resource.

  3. Dopo aver aperto la risorsa hub IoT, fare clic sullo strumento Dispositivi IoT e quindi su Aggiungi nella parte superiore.When your IoT hub resource is opened, click the IoT Devices tool, and then click Add at the top.

    Creare l'identità del dispositivo nel portale

  4. Specificare un nome per il nuovo dispositivo, ad esempio myDeviceId e fare clic su Salva.Provide a name for your new device, such as myDeviceId, and click Save. In questo modo viene creata una nuova identità del dispositivo per l'hub IoT.This action 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.

    Aggiungere un nuovo dispositivo

  5. Nell'elenco dei dispositivi fare clic sul dispositivo appena creato e copiare la Stringa di connessione - chiave primaria.In the device list, click the newly created device and copy the Connection string---primary key to use later.

    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.

Per aggiungere un dispositivo all'hub IoT, è anche possibile usare l'estensione IoT dell'interfaccia della riga di comando di Azure 2.0.You can also use the IoT extension for Azure CLI 2.0 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.