Todos os produtos
Search
Central de documentação

MaxCompute:Visão geral do SDK para Java

Última atualização: Jun 26, 2026

O MaxCompute SDK for Java oferece um conjunto de interfaces Java para gerenciar e interagir com o MaxCompute programaticamente. Use o SDK para gerenciar projetos, executar instruções SQL, manipular tabelas, transferir dados pelo Tunnel e gerenciar recursos e funções.

O acesso aos serviços de computação e armazenamento do MaxCompute via SDK gera as mesmas cobranças aplicadas a outros métodos de acesso. Para detalhes sobre preços, consulte Preços de armazenamento (pagamento conforme o uso) , Preços de computação (pagamento conforme o uso) e Preços de download (pagamento conforme o uso) .

Pacotes do SDK

O MaxCompute SDK for Java é distribuído como um conjunto de pacotes Maven.

Este tópico descreve as interfaces principais comuns do MaxCompute. Para mais informações, consulte SDK Java Doc.

Para mais informações, consulte Taxas de armazenamento (pagamento conforme o uso), Taxas de computação (pagamento conforme o uso) e Taxas de download (pagamento conforme o uso).

Pacote

Descrição

odps-sdk-core

Recursos principais: gerencia tabelas e projetos, acessa o serviço Tunnel

odps-sdk-commons

Utilitários comuns

odps-sdk-udf

Funcionalidades de função definida pelo usuário (UDF)

odps-sdk-mapred

Funcionalidades MapReduce

odps-sdk-graph

Graph SDK for Java

Para a referência completa da API, consulte ODPS SDK Core 0.45.1-public API.

Adicionar a dependência Maven

Adicione odps-sdk-core ao seu arquivo pom.xml:

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

Para encontrar a versão mais recente, pesquise por odps-sdk-core em search.maven.org.

É necessário usar a versão 0.27.2-public ou posterior do SDK para utilizar os novos tipos de dados introduzidos no MaxCompute V2.0.

Inicializar o cliente

O objeto Odps é o ponto de entrada para todas as operações do SDK. Ele fornece acesso a todos os recursos do MaxCompute: projetos, tabelas, instâncias, recursos e funções.

Crie o objeto Odps passando uma AliyunAccount para seu construtor. A AliyunAccount requer um AccessKey ID e um AccessKey secret, que juntos formam um par de AccessKey usado para autenticação.

// 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>");

Substitua os seguintes espaços reservados pelos valores reais:

Espaço reservado

Descrição

<your-odps-endpoint>

O endpoint do MaxCompute para sua região, por exemplo, http://service.odps.aliyun.com/api

<your-project>

O nome do seu projeto MaxCompute

Referência rápida

Cada classe de coleção no objeto Odps corresponde a um conjunto de operações do SDK:

Operação

Chamada do SDK

Listar todas as tabelas

odps.tables()

Obter uma tabela específica

odps.tables().get("table_name")

Listar todas as instâncias

odps.instances()

Obter uma instância específica

odps.instances().get("instance_id")

Listar todos os recursos

odps.resources()

Obter um recurso específico

odps.resources().get("resource_name")

Listar todas as funções

odps.functions()

Obter uma função específica

odps.functions().get("function_name")

Executar uma instrução SQL

SQLTask.run(odps, sql)

Obter detalhes do projeto

odps.projects().get("project_name")

Classes principais

SQLTask

A classe SQLTask executa instruções SQL no MaxCompute. Chame SQLTask.run() para enviar uma instrução; ela retorna um objeto Instance usado para consultar o status e recuperar resultados.

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();
        }
    }
}

Notas de uso:

  • Envie apenas uma instrução SQL por chamada de SQLTask.run().

  • Para criar uma tabela programaticamente, passe uma instrução CREATE TABLE para SQLTask.run(). A classe Table não suporta criação de tabelas. Para a sintaxe de CREATE TABLE, consulte Operações de tabela.

Instances e Instance

Instances é a coleção de todas as instâncias no projeto. Já Instance representa uma única instância e expõe informações de status, tempo e resumo de tarefas.

// 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 e Project

Projects é a coleção de todos os projetos MaxCompute acessíveis com suas credenciais. A classe Project armazena os metadados de um único projeto.

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

Tables e Table

Tables é a coleção de todas as tabelas no projeto padrão. Use Table para inspecionar o esquema e as partições de uma tabela.

// 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 e Resource

Resources é a coleção de todos os recursos no projeto. Os recursos incluem arquivos e referências de tabela usados por UDFs e jobs 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() + ")";
    }
}

Criar um recurso de arquivo:

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);

Criar um recurso de tabela:

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

Functions e Function

Functions é a coleção de todas as funções no projeto. Use Function para ler ou criar UDFs registradas no 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();

Criar uma função:

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

O Tunnel baseia-se no Tunnel SDK e permite upload e download em massa de dados de tabelas do MaxCompute. Views não são suportadas.

MapReduce

Para as classes e métodos do SDK compatíveis com o MaxCompute MapReduce, consulte Visão geral.

Próximos passos

Referências