Questa pagina è stata tradotta dall'API Cloud Translation.

Guida rapida di Java

Le rapide spiegano come configurare ed eseguire un'app che chiama un'API Google Workspace.

I comandi iniziali di Google Workspace utilizzano le librerie client API per gestire alcuni dettagli del flusso di autenticazione e autorizzazione. Ti consigliamo di utilizzare le librerie client per le tue app. Questa guida rapida utilizza un approccio di autenticazione semplificato, adatto a un ambiente di test. Per un ambiente di produzione, ti consigliamo di informarti sull'autenticazione e sull'autorizzazione prima di scegliere le credenziali di accesso appropriate per la tua app.

Crea un'applicazione a riga di comando Java che invii richieste all'API Google Chat.

Obiettivi

Configurare l'ambiente.
Configura il Sample.
Esegui l'esempio.

Prerequisiti

Un account Google Workspace aziendale o aziendale con accesso a Google Chat.

Configura l'ambiente

Per completare questa guida rapida, configura l'ambiente.

Abilita l'API

Prima di utilizzare le API di Google, devi attivarle in un progetto Google Cloud. Puoi attivare una o più API in un singolo progetto Google Cloud.

Nella console Google Cloud, abilita l'API Google Chat.

Attiva l'API

Configura la schermata per il consenso OAuth

Se utilizzi un nuovo progetto Google Cloud per completare questa guida rapida, configura la schermata di consenso di OAuth e aggiungi te stesso come utente di test. Se hai già hai completato questo passaggio per il tuo progetto Cloud, passa alla sezione successiva.

Nella console Google Cloud, vai a Menu > API e servizi > Schermata del consenso OAuth.
Vai alla schermata per il consenso OAuth
In Tipo di utente, seleziona Interno e poi fai clic su Crea.
Compila il modulo di registrazione dell'app, quindi fai clic su Salva e continua.
Per il momento, puoi saltare l'aggiunta di ambiti e fare clic su Salva e continua. In futuro, quando crei un'app da utilizzare al di fuori della tua organizzazione Google Workspace, devi modificare il Tipo di utente in Esterno, quindi aggiungere gli ambiti di autorizzazione richiesti dalla tua app.
Esamina il riepilogo della registrazione dell'app. Per apportare modifiche, fai clic su Modifica. Se l'app la registrazione sembra a posto, fai clic su Torna alla Dashboard.

Autorizzare le credenziali per un'applicazione desktop

Per autenticare gli utenti finali e accedere ai dati utente nella tua app, devi: Creare uno o più ID client OAuth 2.0. L'ID client viene utilizzato per identificare una singola app nei server OAuth di Google. Se l'app viene eseguita su più piattaforme, devi creare un ID client separato per ogni piattaforma.

Nella console Google Cloud, vai a Menu > API e Servizi > Credenziali.
Vai a credenziali
Fai clic su Crea credenziali > ID client OAuth.
Fai clic su Tipo di applicazione > App desktop.
Nel campo Nome, digita un nome per la credenziale. Questo nome viene visualizzato solo nella console Google Cloud.
Fai clic su Crea. Viene visualizzata la schermata del client OAuth creato, che mostra il nuovo ID client e il nuovo client secret.
Fai clic su OK. Le credenziali appena create vengono visualizzate nella sezione ID client OAuth 2.0.
Salva il file JSON scaricato come credentials.json e spostalo nella directory di lavoro.

Configurare l'app Google Chat

Per chiamare l'API Google Chat, devi configurare una App Google Chat. Per qualsiasi richiesta di scrittura, Google Chat attribuisce l'app Google Chat nella UI utilizzando le seguenti informazioni.

Nella console Google Cloud, vai alla pagina Configurazione dell'API Chat:

Vai alla pagina di configurazione dell'API Chat
In Informazioni sull'applicazione, inserisci le seguenti informazioni:
1. Nel campo Nome app, inserisci Chat API quickstart app.
2. Nel campo URL avatar, inserisci https://developers.google.com/chat/images/quickstart-app-avatar.png.
3. Nel campo Description (Descrizione), inserisci Quickstart for calling the Chat API.
Nella sezione Funzionalità interattive, fai clic su Attiva funzionalità interattive. disattiva le funzionalità interattive per App Chat.
Fai clic su Salva.

Preparare lo spazio di lavoro

Nella directory di lavoro, crea una nuova struttura di progetto:

gradle init --type basic
mkdir -p src/main/java src/main/resources

Nella directory src/main/resources/, copia il file credentials.json scaricati in precedenza.

Apri il file build.gradle predefinito e sostituisci i relativi contenuti con il seguente codice:

chat/quickstart/build.gradle

Visualizza su GitHub

apply plugin: 'java'
apply plugin: 'application'

mainClassName = 'ChatQuickstart'
sourceCompatibility = 11
targetCompatibility = 11
version = '1.0'

repositories {
    mavenCentral()
}

dependencies {
    implementation 'com.google.auth:google-auth-library-oauth2-http:1.23.0'
    implementation 'com.google.api-client:google-api-client:1.33.0'
    implementation 'com.google.api.grpc:proto-google-cloud-chat-v1:0.8.0'
    implementation 'com.google.api:gax:2.48.1'
    implementation 'com.google.cloud:google-cloud-chat:0.1.0'
    implementation 'com.google.oauth-client:google-oauth-client-jetty:1.34.1'
}

Configura il Sample

Nella directory src/main/java/, crea un nuovo file Java con un nome corrisponde al valore mainClassName nel file build.gradle.

Includi il seguente codice nel nuovo file Java:

chat/quickstart/src/main/java/ChatQuickstart.java

Visualizza su GitHub

import com.google.api.client.auth.oauth2.Credential;
import com.google.api.client.extensions.java6.auth.oauth2.AuthorizationCodeInstalledApp;
import com.google.api.client.extensions.jetty.auth.oauth2.LocalServerReceiver;
import com.google.api.client.googleapis.auth.oauth2.GoogleAuthorizationCodeFlow;
import com.google.api.client.googleapis.auth.oauth2.GoogleClientSecrets;
import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.client.util.store.FileDataStoreFactory;
import com.google.api.gax.core.FixedCredentialsProvider;
import com.google.auth.Credentials;
import com.google.auth.oauth2.AccessToken;
import com.google.auth.oauth2.UserCredentials;
import com.google.chat.v1.ChatServiceClient;
import com.google.chat.v1.ChatServiceSettings;
import com.google.chat.v1.ListSpacesRequest;
import com.google.chat.v1.Space;
import com.google.protobuf.util.JsonFormat;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Collections;
import java.util.Date;
import java.util.List;

/* class to demonstrate use of Google Chat API spaces list API */
public class ChatQuickstart {
  /** Directory to store authorization tokens for this application. */
  private static final String TOKENS_DIRECTORY_PATH = "tokens";

  /**
   * Global instance of the scopes required by this quickstart. If modifying these scopes, delete
   * your previously saved tokens/ folder.
   */
  private static final List<String> SCOPES =
      Collections.singletonList("https://www.googleapis.com/auth/chat.spaces.readonly");

  /** Global instance of the JSON factory. */
  private static final JsonFactory JSON_FACTORY = GsonFactory.getDefaultInstance();

  private static final String CREDENTIALS_FILE_PATH = "/credentials.json";

  /**
   * Run the OAuth2 flow for local/installed app.
   *
   * @return An authorized Credential object.
   * @throws IOException If the credentials.json file cannot be found.
   */
  private static Credentials getCredentials() throws Exception {
    // Load client secrets.
    InputStream credentialsFileInputStream =
        ChatQuickstart.class.getResourceAsStream(CREDENTIALS_FILE_PATH);
    if (credentialsFileInputStream == null) {
      throw new FileNotFoundException("Credentials file resource not found.");
    }
    GoogleClientSecrets clientSecrets =
        GoogleClientSecrets.load(JSON_FACTORY, new InputStreamReader(credentialsFileInputStream));

    // Set up authorization code flow.
    GoogleAuthorizationCodeFlow flow =
        new GoogleAuthorizationCodeFlow.Builder(
                GoogleNetHttpTransport.newTrustedTransport(), JSON_FACTORY, clientSecrets, SCOPES)
            // Set these two options to generate refresh token alongside access token.
            .setDataStoreFactory(new FileDataStoreFactory(new File(TOKENS_DIRECTORY_PATH)))
            .setAccessType("offline")
            .build();

    // Authorize.
    Credential credential =
        new AuthorizationCodeInstalledApp(flow, new LocalServerReceiver()).authorize("user");

    // Build and return an authorized Credential object
    AccessToken accessToken =
        new AccessToken(
            credential.getAccessToken(),
            new Date(
                // put the actual expiry date of access token here
                System.currentTimeMillis()));
    return UserCredentials.newBuilder()
        .setAccessToken(accessToken)
        .setRefreshToken(credential.getRefreshToken())
        .setClientId(clientSecrets.getInstalled().getClientId())
        .setClientSecret(clientSecrets.getInstalled().getClientSecret())
        .build();
  }

  public static void main(String... args) throws Exception {
    // Override default service settings to supply user credentials.
    Credentials credentials = getCredentials();

    // Create the ChatServiceSettings with the credentials
    ChatServiceSettings chatServiceSettings =
        ChatServiceSettings.newBuilder()
            .setCredentialsProvider(FixedCredentialsProvider.create(credentials))
            .build();

    try (ChatServiceClient chatServiceClient = ChatServiceClient.create(chatServiceSettings)) {
      ListSpacesRequest request =
          ListSpacesRequest.newBuilder()
              // Filter spaces by space type (SPACE or GROUP_CHAT or
              // DIRECT_MESSAGE).
              .setFilter("spaceType = \"SPACE\"")
              .build();

      // Iterate over results and resolve additional pages automatically.
      for (Space response : chatServiceClient.listSpaces(request).iterateAll()) {
        System.out.println(JsonFormat.printer().print(response));
      }
    }
  }
}

Esegui il sample

Esegui l'esempio:
```
gradle run
```

La prima volta che esegui il sample, ti viene chiesto di autorizzare l'accesso:
1. Se non hai ancora eseguito l'accesso al tuo Account Google, accedi quando richiesto. Se Hai eseguito l'accesso a più account, selezionane uno da utilizzare per l'autorizzazione.
2. Fai clic su Accept (accetta).
L'applicazione Java esegue e chiama l'API Google Chat.

Le informazioni di autorizzazione vengono memorizzate nel file system, quindi la volta successiva che esegui il codice di esempio non ti verrà richiesta l'autorizzazione.

Passaggi successivi

Documentazione Javadoc dell'API Google Chat