Tous les produits
Search
Centre de documentation

MaxCompute:Présentation du SDK Java

Dernière mise à jour :Aug 10, 2026

Le SDK MaxCompute pour Java fournit un ensemble d'interfaces Java permettant de gérer et d'interagir avec MaxCompute par programmation. Utilisez le SDK pour gérer les projets, exécuter des instructions SQL, manipuler les tables, transférer des données via Tunnel, ainsi que pour gérer les ressources et les fonctions.

L'accès aux services de calcul et de stockage de MaxCompute via le SDK engendre les mêmes frais que l'accès par d'autres méthodes. Pour plus d'informations sur la tarification, consultez les rubriques suivantes : Tarification du stockage (paiement à l'utilisation) , Tarification du calcul (paiement à l'utilisation) et Tarification du téléchargement (paiement à l'utilisation) .

Packages du SDK

Le SDK MaxCompute pour Java est distribué sous forme de plusieurs packages Maven.

Cette rubrique décrit les interfaces principales courantes de MaxCompute. Pour plus d'informations, consultez la documentation SDK Java Doc.

Pour plus d'informations, consultez les rubriques suivantes : Frais de stockage (paiement à l'utilisation), Frais de calcul (paiement à l'utilisation) et Frais de téléchargement (paiement à l'utilisation).

Package Description
odps-sdk-core Fonctionnalités principales : gestion des tables et des projets, accès au service Tunnel
odps-sdk-commons Utilitaires communs
odps-sdk-udf Fonctionnalités des fonctions définies par l'utilisateur (UDF)
odps-sdk-mapred Fonctionnalités MapReduce
odps-sdk-graph SDK Graph pour Java

Pour consulter la référence complète de l'API, voir ODPS SDK Core 0.45.1-public API.

Ajout de la dépendance Maven

Ajoutez odps-sdk-core à votre fichier pom.xml :

<dependency>
  <groupId>com.aliyun.odps</groupId>
  <artifactId>odps-sdk-core</artifactId>
  <version>X.X.X-public</version>
</dependency>

Pour trouver la dernière version, recherchez odps-sdk-core sur search.maven.org.

La version 0.27.2-public ou ultérieure du SDK est requise pour utiliser les nouveaux types de données introduits dans MaxCompute V2.0.

Initialisation du client

L'objet Odps constitue le point d'entrée pour toutes les opérations du SDK. Il permet d'accéder à toutes les ressources MaxCompute : projets, tables, instances, ressources et fonctions.

Créez l'objet Odps en transmettant un objet AliyunAccount à son constructeur. L'objet AliyunAccount accepte un ID AccessKey et un secret AccessKey, qui forment ensemble une paire de clés AccessKey utilisée pour l'authentification.

// Store your AccessKey credentials as environment variables rather than
// hardcoding them. Using an Alibaba Cloud account's AccessKey pair grants
// full API access — create and use a RAM user for routine operations.
// To create a RAM user, see the Resource Access Management (RAM) console.
Account account = new AliyunAccount(
    System.getenv("ALIBABA_CLOUD_ACCESS_KEY_ID"),
    System.getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET")
);
Odps odps = new Odps(account);
odps.setEndpoint("<your-odps-endpoint>");
odps.setDefaultProject("<your-project>");

Remplacez les espaces réservés suivants par les valeurs réelles :

Espace réservé Description
<your-odps-endpoint> Le point de terminaison MaxCompute pour votre région, par exemple http://service.odps.aliyun.com/api
<your-project> Le nom de votre projet MaxCompute

Référence rapide

Chaque classe de collection de l'objet Odps correspond à un ensemble d'opérations du SDK :

Opération Appel SDK
Répertorier toutes les tables odps.tables()
Obtenir une table spécifique odps.tables().get("table_name")
Répertorier toutes les instances odps.instances()
Obtenir une instance spécifique odps.instances().get("instance_id")
Répertorier toutes les ressources odps.resources()
Obtenir une ressource spécifique odps.resources().get("resource_name")
Répertorier toutes les fonctions odps.functions()
Obtenir une fonction spécifique odps.functions().get("function_name")
Exécuter une instruction SQL SQLTask.run(odps, sql)
Obtenir les détails du projet odps.projects().get("project_name")

Classes principales

SQLTask

La classe SQLTask permet d'exécuter des instructions SQL dans MaxCompute. Appelez la méthode SQLTask.run() pour soumettre une instruction ; celle-ci renvoie un objet Instance que vous utilisez pour interroger l'état et récupérer les résultats.

import java.util.List;
import com.aliyun.odps.Instance;
import com.aliyun.odps.Odps;
import com.aliyun.odps.OdpsException;
import com.aliyun.odps.account.Account;
import com.aliyun.odps.account.AliyunAccount;
import com.aliyun.odps.data.Record;
import com.aliyun.odps.task.SQLTask;

public class RunSqlExample {
    private static final String ACCESS_ID  = System.getenv("ALIBABA_CLOUD_ACCESS_KEY_ID");
    private static final String ACCESS_KEY = System.getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET");
    private static final String ENDPOINT   = "http://service.odps.aliyun.com/api";
    private static final String PROJECT    = "<your-project>";

    public static void main(String[] args) {
        Account account = new AliyunAccount(ACCESS_ID, ACCESS_KEY);
        Odps odps = new Odps(account);
        odps.setEndpoint(ENDPOINT);
        odps.setDefaultProject(PROJECT);

        String sql = "select category from iris;";
        try {
            // Submit the SQL statement and wait for it to complete
            Instance instance = SQLTask.run(odps, sql);
            instance.waitForSuccess();

            // Retrieve and print results
            List<Record> records = SQLTask.getResult(instance);
            for (Record r : records) {
                System.out.println(r.get(0).toString());
            }
        } catch (OdpsException e) {
            e.printStackTrace();
        }
    }
}

Remarques d'utilisation :

  • Ne soumettez qu'une seule instruction SQL par appel à SQLTask.run().

  • Pour créer une table par programmation, transmettez une instruction CREATE TABLE à la méthode SQLTask.run(). La classe Table ne prend pas en charge la création de tables. Pour connaître la syntaxe de l'instruction CREATE TABLE, consultez la rubrique Opérations sur les tables.

Instances et Instance

La classe Instances représente la collection de toutes les instances du projet. La classe Instance représente une instance unique et expose des informations sur l'état, le timing et le résumé des tâches.

// Iterate over all instances
for (Instance i : odps.instances()) {
    // process each instance
}

// Get a specific instance and inspect its status
Instance instance = odps.instances().get("instance_id");
Date startTime = instance.getStartTime();
Date endTime   = instance.getEndTime();

Status instanceStatus = instance.getStatus();
String statusStr;
if (instanceStatus == Status.TERMINATED) {
    statusStr = TaskStatus.Status.SUCCESS.toString();
    Map<String, TaskStatus> taskStatus = instance.getTaskStatus();
    for (Entry<String, TaskStatus> entry : taskStatus.entrySet()) {
        if (entry.getValue().getStatus() != TaskStatus.Status.SUCCESS) {
            statusStr = entry.getValue().getStatus().toString();
            break;
        }
    }
} else {
    statusStr = instanceStatus.toString();
}

// Get the task summary
TaskSummary summary = instance.getTaskSummary("task_name");
String summaryText  = summary.getSummaryText();

Projects et Project

La classe Projects représente la collection de tous les projets MaxCompute accessibles avec vos identifiants. La classe Project contient les métadonnées d'un projet unique.

// Get a specific project
Project p = odps.projects().get("project_name");
p.reload();

Tables et Table

La classe Tables représente la collection de toutes les tables du projet par défaut. Utilisez la classe Table pour inspecter le schéma et les partitions d'une table.

// Iterate over all tables
for (Table t : odps.tables()) {
    // process each table
}

// Get a table and iterate over its columns
Table table = odps.tables().get("table_name");
for (Column c : table.getSchema().getColumns()) {
    String   name = c.getName();
    TypeInfo type = c.getTypeInfo();
}

// Access a specific partition
Table t = odps.tables().get("table_name");
t.reload();
Partition part = t.getPartition(new PartitionSpec("partition_col=partition_col_value"));
part.reload();

Resources et Resource

La classe Resources représente la collection de toutes les ressources du projet. Les ressources incluent les fichiers et les références de table utilisés par les UDF et les travaux MapReduce.

// Iterate over all resources
for (Resource r : odps.resources()) {
    // process each resource
}

// Get a resource and check its type
Resource r = odps.resources().get("resource_name");
r.reload();
if (r.getType() == Resource.Type.TABLE) {
    TableResource tr = new TableResource(r);
    String tableSource = tr.getSourceTable().getProject() + "."
        + tr.getSourceTable().getName();
    if (tr.getSourceTablePartition() != null) {
        tableSource += " partition(" + tr.getSourceTablePartition().toString() + ")";
    }
}

Création d'une ressource de fichier :

String projectName = "my_project";
String source      = "my_local_file.txt";
File file          = new File(source);
InputStream is     = new FileInputStream(file);

FileResource resource = new FileResource();
resource.setName(file.getName());
odps.resources().create(projectName, resource, is);

Création d'une ressource de table :

TableResource resource = new TableResource(tableName, tablePrj, partitionSpec);
resource.setName("table_resource_name");
odps.resources().update(projectName, resource);

Functions et Function

La classe Functions représente la collection de toutes les fonctions du projet. Utilisez la classe Function pour lire ou créer des UDF enregistrées dans MaxCompute.

// Iterate over all functions
for (Function f : odps.functions()) {
    // process each function
}

// Get a function and list its associated resources
Function f = odps.functions().get("function_name");
List<Resource> resources = f.getResources();

Création d'une fonction :

String classType = "com.aliyun.odps.mapred.open.example.WordCount";
ArrayList<String> resourceList = new ArrayList<>();
for (String r : "resource1:resource2".split(":")) {
    resourceList.add(r);
}

Function func = new Function();
func.setName("function_name");
func.setClassType(classType);
func.setResources(resourceList);
odps.functions().create(projectName, func);

MaxCompute Tunnel

Tunnel est basé sur le SDK Tunnel et prend en charge le chargement et le téléchargement en masse de données depuis les tables MaxCompute. Les vues ne sont pas prises en charge.

MapReduce

Pour obtenir la liste des classes et méthodes du SDK prises en charge par MaxCompute MapReduce, consultez la rubrique Présentation.

Étapes suivantes

  • Pour le traitement des données basé sur Python dans MaxCompute, consultez la rubrique Présentation.

  • Pour la référence complète de l'API Java, consultez la documentation ODPS SDK Core 0.45.1-public API sur javadoc.io.

Références