API Hello Analytics: inicio rápido en Java para las cuentas de servicio

Este tutorial te servirá de guía por los pasos necesarios para acceder a una cuenta de Google Analytics, consultar las API de Google Analytics, gestionar las respuestas de la API y enviar los resultados. Para ello, se usan la API de informes centrales v3.0, la API de administración v3.0 y OAuth 2.0.

Paso 1: habilitar la API de Analytics

Para empezar a usar la API de Google Analytics, primero debes utilizar la herramienta de configuración, que te guiará por los pasos necesarios para crear un proyecto en la consola de la API de Google, habilitar la API y crear las credenciales.

Crear un ID de cliente

  1. Abre la página Service accounts (Cuentas de servicio). Si se te solicita, selecciona un proyecto.
  2. Haz clic en Create service account (Crear cuenta de servicio).
  3. En la ventana Create service account (Crear cuenta de servicio), escribe el nombre de la cuenta de servicio y selecciona Furnish a new private key (Suministrar una nueva clave privada). Si quieres conceder autoridad en todo el dominio de G Suite a la cuenta de servicio, selecciona también Enable G Suite Domain-wide Delegation (Habilitar delegación de todo el dominio de G Suite). A continuación, haz clic en Create (Crear).

El nuevo par de claves pública/privada se genera y se descarga en el equipo, lo que sirve de copia única de esta clave. Eres responsable de almacenarla de forma segura.

Agregar la cuenta de servicio a la cuenta de Google Analytics

La cuenta de servicio recién creada tendrá la dirección de correo electrónico &ltprojectId&gt-&ltuniqueId&gt@developer.gserviceaccount.com. Utiliza esta dirección para agregar un usuario a la cuenta de Google Analytics a la que quieras acceder a través de la API. Para este tutorial solo se necesitan los permisos Leer y analizar.

Paso 2: instalar la biblioteca de cliente de Google

Para instalar el cliente Java de la API de Google Analytics, debes descargar un archivo zip que contenga todos los archivos jar que debes extraer y copiar en la ruta de clases de Java.

  1. Descarga la biblioteca de cliente Java de Google Analytics, que está incluida en un archivo ZIP con todas las dependencias necesarias.
  2. Extrae el archivo ZIP.
  3. Agrega todos los archivos jar del directorio libs a tu ruta de clases.
  4. Agrega el archivo jar google-api-services-analytics-v3-[version].jar a tu ruta de clases.

Paso 3: configurar la muestra

Deberás crear un archivo denominado HelloAnalytics.java, que contendrá el código de muestra indicado.

  1. Copia o descarga el siguiente código fuente en HelloAnalytics.java.
  2. Traslada el archivo client_secrets.p12 descargado anteriormente al mismo directorio que el código de muestra.
  3. Reemplaza los valores de SERVICE_ACCOUNT_EMAIL y KEY_FILE_LOCATION por los valores adecuados de Developer Console.
import com.google.api.client.googleapis.auth.oauth2.GoogleCredential;
import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.http.HttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.gson.GsonFactory;

import com.google.api.services.analytics.Analytics;
import com.google.api.services.analytics.AnalyticsScopes;
import com.google.api.services.analytics.model.Accounts;
import com.google.api.services.analytics.model.GaData;
import com.google.api.services.analytics.model.Profiles;
import com.google.api.services.analytics.model.Webproperties;

import java.io.File;
import java.io.IOException;

/**
 * A simple example of how to access the Google Analytics API using a service
 * account.
 */
public class HelloAnalytics {

  private static final String APPLICATION_NAME = "Hello Analytics";
  private static final JsonFactory JSON_FACTORY = GsonFactory.getDefaultInstance();
  private static final String KEY_FILE_LOCATION = "/path/to/your.p12";
  private static final String SERVICE_ACCOUNT_EMAIL = "<SERVICE_ACCOUNT_EMAIL>@developer.gserviceaccount.com";
  public static void main(String[] args) {
    try {
      Analytics analytics = initializeAnalytics();

      String profile = getFirstProfileId(analytics);
      System.out.println("First Profile Id: "+ profile);
      printResults(getResults(analytics, profile));
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  private static Analytics initializeAnalytics() throws Exception {
    // Initializes an authorized analytics service object.

    // Construct a GoogleCredential object with the service account email
    // and p12 file downloaded from the developer console.
    HttpTransport httpTransport = GoogleNetHttpTransport.newTrustedTransport();
    GoogleCredential credential = new GoogleCredential.Builder()
        .setTransport(httpTransport)
        .setJsonFactory(JSON_FACTORY)
        .setServiceAccountId(SERVICE_ACCOUNT_EMAIL)
        .setServiceAccountPrivateKeyFromP12File(new File(KEY_FILE_LOCATION))
        .setServiceAccountScopes(AnalyticsScopes.all())
        .build();

    // Construct the Analytics service object.
    return new Analytics.Builder(httpTransport, JSON_FACTORY, credential)
        .setApplicationName(APPLICATION_NAME).build();
  }

  private static String getFirstProfileId(Analytics analytics) throws IOException {
    // Get the first view (profile) ID for the authorized user.
    String profileId = null;

    // Query for the list of all accounts associated with the service account.
    Accounts accounts = analytics.management().accounts().list().execute();

    if (accounts.getItems().isEmpty()) {
      System.err.println("No accounts found");
    } else {
      String firstAccountId = accounts.getItems().get(0).getId();

      // Query for the list of properties associated with the first account.
      Webproperties properties = analytics.management().webproperties()
          .list(firstAccountId).execute();

      if (properties.getItems().isEmpty()) {
        System.err.println("No Webproperties found");
      } else {
        String firstWebpropertyId = properties.getItems().get(0).getId();

        // Query for the list views (profiles) associated with the property.
        Profiles profiles = analytics.management().profiles()
            .list(firstAccountId, firstWebpropertyId).execute();

        if (profiles.getItems().isEmpty()) {
          System.err.println("No views (profiles) found");
        } else {
          // Return the first (view) profile associated with the property.
          profileId = profiles.getItems().get(0).getId();
        }
      }
    }
    return profileId;
  }

  private static GaData getResults(Analytics analytics, String profileId) throws IOException {
    // Query the Core Reporting API for the number of sessions
    // in the past seven days.
    return analytics.data().ga()
        .get("ga:" + profileId, "7daysAgo", "today", "ga:sessions")
        .execute();
  }

  private static void printResults(GaData results) {
    // Parse the response from the Core Reporting API for
    // the profile name and number of sessions.
    if (results != null && !results.getRows().isEmpty()) {
      System.out.println("View (Profile) Name: "
        + results.getProfileInfo().getProfileName());
      System.out.println("Total Sessions: " + results.getRows().get(0).get(0));
    } else {
      System.out.println("No results found");
    }
  }
}

Paso 4: ejecutar la muestra

Después de haber habilitado la API de Analytics, de haber instalado la biblioteca de cliente para Java de las API de Google y de haber configurado el código fuente, la muestra está lista para ejecutarse.

Si utilizas un IDE, comprueba que tengas un destino de ejecución predeterminado configurado como la clase HelloAnalytics. De lo contrario, puedes compilar y ejecutar la aplicación desde la línea de comandos:

  1. Compila muestra con el siguiente comando:
    javac -classpath /path/to/google/lib/*:/path/to/google/lib/libs/* HelloAnalytics.java
  2. Ejecuta la muestra con el siguiente comando:
    java -classpath ./:/path/to/google/lib/*:/path/to/google/lib/libs/* HelloAnalytics

Cuando finalices estos pasos, la muestra envía el nombre de la primera vista (perfil) de Google Analytics del usuario autorizado y el número de sesiones de los últimos siete días.

Con el objeto de servicio de Analytics autorizado ya puedes ejecutar cualquiera de las muestras de código que se encuentran en los documentos de referencia de la API de administración. Por ejemplo, podrías intentar cambiar el código para usar el método accountSummaries.list.