Ejercicio: Configuración de la aplicación de Java mediante Maven

15 minutos

En esta unidad, creará una aplicación de consola básica mediante el uso de un IDE que elija para editar el código. Opcionalmente, puede usar su terminal preferido para ejecutar el código.

Creación de recursos de Azure Cosmos DB

Para completar este laboratorio, Microsoft Learn le proporciona un espacio aislado de Azure gratuito en el que puede crear cuentas y recursos. Configurará una cuenta de Azure Cosmos DB en esta suscripción y luego creará una base de datos y un contenedor.

Inicie sesión en Azure Portal con la misma cuenta con la que ha activado el espacio aislado.
Con Azure Portal, cree una cuenta de Azure Cosmos DB y póngale el nombre que quiera. Cuando llegue la oportunidad de elegir un grupo de recursos para su cuenta, busque el grupo de recursos [Grupo de recursos de espacio aislado] y selecciónelo.
Cree una base de datos llamada Users en la cuenta de Azure Cosmos DB.
En la base de datos Usuarios, cree un contenedor denominado WebCustomers con una clave de partición de /userId. Aprovisione 400 RU/s para WebCustomers.

Creación del directorio de trabajo

Le proporcionamos una plantilla para la aplicación de Java. Clone el repositorio de plantillas en el sistema.
```
git clone https://github.com/MicrosoftDocs/mslearn-cosmos-java-sql.git
```
Abra el explorador de archivos de Windows y vaya al repositorio clonado. Especifique el subdirectorio java_lab.

Importante

Todo el trabajo de este módulo estará en el subdirectorio java_lab.
La plantilla contiene un archivo pom.xml de Maven que ya extrae las dependencias necesarias para el proyecto. Abra este archivo y examínelo para encontrar la dependencia siguiente:
```
<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-cosmos</artifactId>
    <version>LATEST</version>
</dependency>
```
Esta dependencia extrae la versión más reciente del SDK de Java de Azure Cosmos DB. Puede cerrar este archivo.
Luego, compilará y ejecutará Hola mundo. Con el IDE o el terminal, abra este proyecto. En función del IDE, puede que haya una opción para abrir el archivo pom.xml del subdirectoriojava como proyecto.

Cuando haya abierto el proyecto, vaya a src/main/java/com/azure/cosmos/examples/mslearnbasicapp y abra CosmosApp.java, que es una plantilla para la aplicación de Java que se va a desarrollar. Debe tener el siguiente aspecto:
```
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public final class CosmosApp {

    /** For application to log INFO and ERROR. */
    private static Logger logger = LoggerFactory.getLogger(CosmosApp.class.getSimpleName());

    private CosmosApp() {
        // not called
    }

    /**
    * Main.
    * @param args Command line arguments
    */
    public static void main(final String[] args) {
        logger.info("Hello World.");
    }
}
```
Tal cual, el código de aplicación implementa un proyecto "Hola mundo" simple.
Si el IDE ofrece herramientas para compilar y ejecutar la aplicación de Maven: Compile y ejecute la aplicación mediante el IDE y confirme que la aplicación registra Hello World en el terminal.
Si va a utilizar el terminal para compilar y ejecutar la aplicación Maven: Use el siguiente comando para compilar el proyecto Maven:
```
mvn clean package
```
A continuación, ejecute:
```
mvn exec:java -Dexec.mainClass="com.azure.cosmos.examples.mslearnbasicapp.CosmosApp"  
```
Confirme que la aplicación registra el siguiente resultado en el terminal:
```
INFO: Hello World.
```

Conexión de la aplicación a Azure Cosmos DB

Dentro de la clase CosmosApp, cree las siguientes variables de clase estática para los detalles de la conexión de Azure Cosmos DB:

/** Azure Cosmos DB endpoint URI. */
private static String endpointUri = "<your-cosmosdb-hostname>";

/** Azure Cosmos DB primary key. */
private static String primaryKey = "<your-cosmosdb-master-key>";

Vuelva a Azure Portal, vaya al panel Claves y copie el URI del punto de conexión de Azure Cosmos DB y la clave principal y péguelos en las definiciones de variables anteriores.

Por ejemplo, si el URI es https://cosmosacct.documents.azure.com:443/, la nueva asignación de variables tendrá el siguiente aspecto: private static String endpointUri = "https://cosmosacct.documents.azure.com:443/";. Si la clave principal es elzirrKCnXlacvh1CRAnQdYVbVLspmYHQyYrhx0PltHi8wn5lHVHFnd1Xm3ad5cn4TUcH4U0MSeHsVykkFPHpQ==, la nueva asignación de la variable tendrá el siguiente aspecto: private static String primaryKey = "elzirrKCnXlacvh1CRAnQdYVbVLspmYHQyYrhx0PltHi8wn5lHVHFnd1Xm3ad5cn4TUcH4U0MSeHsVykkFPHpQ==";.

Creación de instancia de CosmosAsyncClient

Ahora vamos a crear una instancia de CosmosAsyncClient, que es la representación del lado cliente del servicio Azure Cosmos DB. Este cliente se usa para configurar y ejecutar solicitudes en el servicio.

En CosmosApp.java, agregue la siguiente declaración de variable estática a la clase CosmosApp:
```
/** Azure Cosmos DB client instance. */
private static CosmosAsyncClient client;

/** Azure Cosmos DB database instance. */
private static CosmosAsyncDatabase database;

/** Azure Cosmos DB container instance. */
private static CosmosAsyncContainer container;
```
Lo más probable es que las clases client, database y container todavía no se hayan importado en el archivo Java. Por lo tanto, ahora es un buen momento para encargarse de ello. Es posible que algunos IDE le permitan importar automáticamente dependencias basadas en el código que escriba y eso puede resultar útil aquí. En general, se espera que cuando se le proporcione un bloque de código para pegarlo, puede que tenga que agregar algunas instrucciones import para que funcione.
Cree un método private void llamado basicOperations sin argumentos en la clase.

Agregue el código siguiente para crear una instancia CosmosAsyncClient en el método basicOperations e incluya el código para comprobar si existe la base de datos Users.

 client = new CosmosClientBuilder()
     .endpoint(endpointUri)
     .key(primaryKey)
     .consistencyLevel(ConsistencyLevel.EVENTUAL)
     .directMode()
     .contentResponseOnWriteEnabled(true)
     .buildAsyncClient();

 database = client.getDatabase("Users");
 container = database.getContainer("WebCustomers");            

 logger.info("Database and container validation complete");

 client.close();

En este momento, el método basicOperations contiene el código para interactuar con Azure Cosmos DB. Pero no se llama a este método en main, por lo que la aplicación todavía sirve para imprimir "Hola mundo". Como comprobación, compile y ejecute CosmosApp.java en el IDE, o bien ejecute el programa en el terminal mediante:
```
mvn clean package
mvn exec:java -Dexec.mainClass="com.azure.cosmos.examples.mslearnbasicapp.CosmosApp"  
```
Confirme que la aplicación aún registra el siguiente resultado en el terminal:
```
INFO: Hello World.
```

Copie y pegue el siguiente código en el método main, a fin de sobrescribir la línea logger.info("Hello World."); actual.

try {
    CosmosApp p = new CosmosApp();
    p.basicOperations();
} catch (CosmosException e) {
    logger.error("Failed while executing app.", e);
} finally {
    logger.info("End of demo, press any key to exit.");
}

Esto desencadenará el código de Azure Cosmos DB en nuestra aplicación.

Compile y ejecute CosmosApp.java en el IDE o ejecute el programa en el terminal usando:
```
mvn clean package
mvn exec:java -Dexec.mainClass="com.azure.cosmos.examples.mslearnbasicapp.CosmosApp"  
```
Es posible que vea un gran número de mensajes de registro en el terminal, algunos de los cuales son generados por el propio SDK. Léalos y confirme que la aplicación registra el siguiente resultado en el terminal:
```
INFO: Database and container validation complete
```

En esta unidad, ha realizado los preparativos para la aplicación de Java de Azure Cosmos DB. Configuró la aplicación de Maven, creó un proyecto básico "Hola mundo" y lo amplió para conectar el proyecto al punto de conexión Azure Cosmos DB.

Le proporcionamos una plantilla para la aplicación de Java. Clonación del repositorio de plantillas en el sistema
```
git clone https://github.com/MicrosoftDocs/mslearn-cosmos-java-sql.git
```
Abra el Explorador de Windows y navegue hasta el repositorio clonado. Especifique el subdirectorio spring_lab.

Importante

Todo el trabajo de este módulo estará en el subdirectorio spring_lab.
La plantilla contiene un archivo pom.xml de Maven que ya extrae las dependencias necesarias para el proyecto. Abra este archivo y examínelo para encontrar la dependencia siguiente:
```
<dependency>
  <groupId>com.azure</groupId>
  <artifactId>azure-spring-data-cosmos</artifactId>
  <version>LATEST</version>
</dependency>
```
Esta dependencia extrae la última versión de Spring Data para Azure Cosmos DB. Puede cerrar este archivo.

Conexión de la aplicación a Azure Cosmos DB

Con el IDE o el terminal, abra este proyecto. En función del IDE, puede que haya una opción para abrir el archivo pom.xml del subdirectorio spring como proyecto. Después de abrir el proyecto, vaya a src/main/resources/ mediante una herramienta de explorador de archivos. Debería ver un archivo llamado application.properties.rename. Spring Data resalta los archivos de configuración mediante parámetros de configuración codificados de forma rígida; para crear el archivo de configuración para el proyecto Spring Data, copie application.properties.rename en application.properties y abra el nuevo archivo application.properties. Verá un mensaje que dice:
```
cosmos.uri=${ACCOUNT_HOST}
cosmos.key=${ACCOUNT_KEY}
cosmos.secondaryKey=${SECONDARY_ACCOUNT_KEY}

dynamic.collection.name=spel-property-collection
# Populate query metrics
cosmos.queryMetricsEnabled=true
```
Rellene ${ACCOUNT_HOST} y ${ACCOUNT_KEY} con un método de su elección, o bien copie y pegue los valores en application.properties, o defina estas variables de entorno en su IDE. En el paso siguiente, encontrará los valores que estas variables deben tener.
Vuelva a Azure Portal, vaya al panel Claves y copie el URI del punto de conexión de Azure Cosmos DB y la clave principal. Como se explicó en el paso anterior, use el método de su elección para asignar el URI del punto de conexión de Azure Cosmos DB y la clave principal a las variables mencionadas anteriormente.

Por ejemplo, si el URI es https://cosmosacct.documents.azure.com:443/y decide pegar el punto de conexión y la clave principal en application.properties, la línea de application.properties tendrá este aspecto: cosmos.uri=https://cosmosacct.documents.azure.com:443/. Si la clave principal es elzirrKCnXlacvh1CRAnQdYVbVLspmYHQyYrhx0PltHi8wn5lHVHFnd1Xm3ad5cn4TUcH4U0MSeHsVykkFPHpQ==, al seguir el mismo proceso, la nueva asignación de la variable tendrá el siguiente aspecto: cosmos.key=elzirrKCnXlacvh1CRAnQdYVbVLspmYHQyYrhx0PltHi8wn5lHVHFnd1Xm3ad5cn4TUcH4U0MSeHsVykkFPHpQ==.

Configuración del cliente de Azure Cosmos DB

Spring Data para Azure Cosmos DB crea automáticamente una instancia del cliente de Azure Cosmos DB en el inicio. El cliente de Azure Cosmos DB es la representación del lado cliente del servicio Azure Cosmos DB, que se usa para ejecutar solicitudes en el servicio. El código puede configurar el cliente de Azure Cosmos DB antes de que se cree una instancia, mediante una serie de métodos de generador junto con propiedades extraídas de application.properties.

Abra CosmosProperties.java. Hemos proporcionado este archivo en un formulario completo, por lo que solo debe examinar su contenido.
```
@ConfigurationProperties(prefix = "cosmos")
public class CosmosProperties {

    private String uri;

    private String key;

    private String secondaryKey;

    private boolean queryMetricsEnabled;

    public String getUri() {
        return uri;
    }

    public void setUri(String uri) {
        this.uri = uri;
    }

    public String getKey() {
        return key;
    }

    public void setKey(String key) {
        this.key = key;
    }

    public String getSecondaryKey() {
        return secondaryKey;
    }

    public void setSecondaryKey(String secondaryKey) {
        this.secondaryKey = secondaryKey;
    }

    public boolean isQueryMetricsEnabled() {
        return queryMetricsEnabled;
    }

    public void setQueryMetricsEnabled(boolean enableQueryMetrics) {
        this.queryMetricsEnabled = enableQueryMetrics;
    }
}
```
Observe los miembros de clases uri, key, secondaryKey y queryMetricsEnabled. Al volver a application.properties, observe que los nombres de los miembros de CosmosProperties se corresponden exactamente con los nombres de propiedad de application.properties. La clase CosmosProperties presenta captadores y establecedores para el resto de la aplicación para acceder a las opciones de configuración de application.properties. Observe que no hay código aquí para extraer la configuración de application.properties: Spring Data reconoce la estructura de este archivo y establece automáticamente las variables miembro después de analizar el archivo de configuración.

Usaremos esta configuración en el futuro, cuando configuremos el cliente de Azure Cosmos DB.
En CosmosSampleConfiguration.java, examine la clase CosmosSampleConfiguration y busque el método cosmosClientBuilder vacío:
```
@Bean
public CosmosClientBuilder cosmosClientBuilder() {
    return null;
}
```
Durante el inicio, Spring Data llamará automáticamente a este método, obtendrá el valor CosmosClientBuilder que este método devuelve y llamará a su método build(), un punto (internamente) en el que se creará una instancia de CosmosAsyncClient basada en las opciones de configuración contenidas en CosmosClientBuilder. Puede utilizar este método para configurar CosmosClientBuilder mediante métodos de generador.
Observe que se usa la inserción de constructores (en lugar de la inserción de campos mediante @Autowired) para crear instancias de la variablepropertiesy rellenar sus variables miembro con valores analizados del archivo de configuración. Esto garantiza que todas las dependencias necesarias estén presentes cuando se crea la instancia de esta clase y facilita la escritura de código de prueba en el futuro.
```
//use constructor injection for spring dependencies 
public CosmosSampleConfiguration(CosmosProperties properties){
    this.properties = properties;
}
```
Podemos usar properties para obtener el URI y la clave para nuestra cuenta de Azure Cosmos DB e implementar cosmosClientBuilder como se muestra a continuación:
```
@Bean
public CosmosClientBuilder cosmosClientBuilder() {
    DirectConnectionConfig directConnectionConfig = DirectConnectionConfig.getDefaultConfig();
    return new CosmosClientBuilder()
        .endpoint(properties.getUri())
        .key(properties.getKey())
        .directMode(directConnectionConfig);
}
```
Esta implementación
1. Extrae el URI y la clave de properties.
2. Los conecta a los métodos de generador endpoint y key.
3. Además, configura la conexión de red con el servicio Azure Cosmos DB. (En modo directo, la aplicación cliente se comunica directamente con las particiones de Azure Cosmos DB de back-end).
Vuelva a CosmosSampleConfiguration.java y busque el método getDatabaseName:
```
@Override
protected String getDatabaseName() { return ""; }
```
Cambie el valor devuelto predeterminado a "Users", el nombre de la base de datos. De esta manera, cuando Spring Data se conecta automáticamente a Azure Cosmos DB durante el inicio, se conectará a la base de datos de *usuarios.
Vaya a WebCustomer.java. Observará que la clase WebCustomer va precedida de una anotación @Container:
```
@Container(containerName = "", ru = "")
```
@Container adopta dos argumentos:
- containerName: nombre del contenedor de Azure Cosmos DB (WebCustomers)
- ru: rendimiento aprovisionado del contenedor. 400 RU/s es un buen valor predeterminado para un ejercicio de Microsoft Learn.
Personalice @Container para su caso de uso, como se muestra a continuación:
```
@Data
@NoArgsConstructor
@AllArgsConstructor
@Container(containerName = "WebCustomers", ru = "400")
public class WebCustomer {
```

En este momento, el proyecto Spring Data está configurado para interactuar con Azure Cosmos DB. Luego, compilará y ejecutará Hola mundo. Vaya a src/main/java/com/azure/cosmos/examples/springexamples y abra CosmosSample.javaa, que es una plantilla para la aplicación de Spring Data que se va a desarrollar. Debe tener el siguiente aspecto:

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
package com.azure.cosmos.examples.springexamples;

import com.azure.cosmos.CosmosException;
import com.azure.cosmos.examples.springexamples.common.CouponsUsed;
import com.azure.cosmos.examples.springexamples.common.OrderHistory;
import com.azure.cosmos.examples.springexamples.common.ShippingPreference;
import com.azure.cosmos.models.CosmosItemResponse;
import com.azure.cosmos.models.PartitionKey;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

@SpringBootApplication
public class CosmosSample implements CommandLineRunner {

    private final Logger logger = LoggerFactory.getLogger(CosmosSample.class);

    private ReactiveWebCustomerRepository reactiveWebCustomerRepository;

    //constructor dependency injection
    public CosmosSample(ReactiveWebCustomerRepository reactiveWebCustomerRepository){
        this.reactiveWebCustomerRepository = reactiveWebCustomerRepository;
    }

    public void run(String... var1) {
        logger.info("Hello world.");
    }
}

Tal cual, el código de aplicación implementa un proyecto "Hola mundo" simple.

Si el IDE ofrece herramientas para compilar y ejecutar la aplicación de Maven: Compile y ejecute la aplicación mediante el IDE y confirme que la aplicación registra Hello World en el terminal.
Si va a utilizar el terminal para compilar y ejecutar la aplicación Maven: Use el siguiente comando para compilar el proyecto Maven:
```
mvn clean package
```
A continuación, ejecute:
```
mvn spring-boot:run
```
Confirme que la aplicación registra el siguiente resultado en el terminal, entre todos los demás resultados:
```
INFO: Hello World.
```

En esta unidad, ha realizado los preparativos para la aplicación de Java de Azure Cosmos DB. Personalizó la aplicación de Maven y amplió un proyecto básico "Hola mundo" para conectarlo a un punto de conexión de Azure Cosmos DB.

Ejercicio: Configuración de la aplicación de Java mediante Maven

Creación de recursos de Azure Cosmos DB

Creación del directorio de trabajo

Conexión de la aplicación a Azure Cosmos DB

Creación de instancia de CosmosAsyncClient

Conexión de la aplicación a Azure Cosmos DB

Configuración del cliente de Azure Cosmos DB

Comentarios