MapOnly example - MaxCompute: Central de Documentação do Alibaba Cloud

Em um job map-only, o mapper grava os registros de saída diretamente em uma tabela do MaxCompute, sem a execução de nenhum reducer. Ao contrário do MapReduce padrão, especifique somente as tabelas de saída, sem a necessidade de definir metadados de chave-valor para a saída do mapper.

Este exemplo demonstra três aspectos:

Configure um job map-only definindo a contagem de reducers como 0
Passe parâmetros por meio do JobConf e leia-os dentro do mapper
Analise como os métodos de ciclo de vida setup, map e cleanup funcionam com execução condicional

Pré-requisitos

Antes de começar, conclua a configuração do ambiente descrita em Primeiros passos.

Prepare as tabelas e os recursos de teste

Crie as tabelas de entrada e saída.

CREATE TABLE wc_in (key STRING, value STRING);
CREATE TABLE wc_out (key STRING, cnt BIGINT);

Adicione o pacote JAR como um recurso.
```
add jar data\resources\mapreduce-examples.jar -f;
```
Omita o -f na primeira vez que adicionar o pacote JAR. O caminho data\resources\mapreduce-examples.jar é relativo ao diretório bin da instalação local do seu cliente MaxCompute.
Importe os dados de teste para wc_in usando o Tunnel. Execute o seguinte comando a partir do diretório bin do cliente MaxCompute, onde o data.txt está localizado.
```
tunnel upload data.txt wc_in;
```
O comando carrega as seguintes linhas em wc_in:
```
hello,odps
hello,odps
```

Executar o job

Execute o seguinte comando no cliente MaxCompute:

jar -resources mapreduce-examples.jar -classpath data\resources\mapreduce-examples.jar
com.aliyun.odps.mapred.open.example.MapOnly wc_in wc_out map

Os argumentos do comando correspondem ao seguinte:

Argumento	Descrição
`-resources mapreduce-examples.jar`	Declara o pacote JAR como uma dependência do job
`-classpath data\resources\mapreduce-examples.jar`	Especifique o caminho para o pacote JAR
`wc_in`	Tabela de entrada
`wc_out`	Tabela de saída
`map`	Defina `option.mapper.map=true` no JobConf e ative o método `map()` para gravar a saída

Resultado esperado

Após a conclusão do job, consulte wc_out:

+------------+------------+
| key        | cnt        |
+------------+------------+
| hello      | 1          |
| hello      | 1          |
+------------+------------+

A tabela contém duas linhas em vez de uma porque um job map-only produz um registro de saída para cada registro de entrada, sem agregação. Cada linha de entrada hello,odps é mapeada para uma linha de saída hello | 1.

Código de exemplo

Para dependências do Project Object Model (POM), consulte Precauções.

package com.aliyun.odps.mapred.open.example;
import java.io.IOException;
import com.aliyun.odps.data.Record;
import com.aliyun.odps.mapred.JobClient;
import com.aliyun.odps.mapred.MapperBase;
import com.aliyun.odps.mapred.conf.JobConf;
import com.aliyun.odps.mapred.utils.SchemaUtils;
import com.aliyun.odps.mapred.utils.InputUtils;
import com.aliyun.odps.mapred.utils.OutputUtils;
import com.aliyun.odps.data.TableInfo;
public class MapOnly {
    public static class MapperClass extends MapperBase {
        @Override
            public void setup(TaskContext context) throws IOException {
            boolean is = context.getJobConf().getBoolean("option.mapper.setup", false);
            /** The main function executes the following logic only if option.mapper.setup is set to true in the JobConf file: */
            if (is) {
                Record result = context.createOutputRecord();
                result.set(0, "setup");
                result.set(1, 1L);
                context.write(result);
            }
        }
        @Override
            public void map(long key, Record record, TaskContext context) throws IOException {
            boolean is = context.getJobConf().getBoolean("option.mapper.map", false);
            /** The main function executes the following logic only if option.mapper.map is set to true in the JobConf file: */
            if (is) {
                Record result = context.createOutputRecord();
                result.set(0, record.get(0));
                result.set(1, 1L);
                context.write(result);
            }
        }
        @Override
            public void cleanup(TaskContext context) throws IOException {
            boolean is = context.getJobConf().getBoolean("option.mapper.cleanup", false);
            /** The main function executes the following logic only if option.mapper.cleanup is set to true in the JobConf file: */
            if (is) {
                Record result = context.createOutputRecord();
                result.set(0, "cleanup");
                result.set(1, 1L);
                context.write(result);
            }
        }
    }
    public static void main(String[] args) throws Exception {
        if (args.length != 2 && args.length != 3) {
            System.err.println("Usage: OnlyMapper <in_table> <out_table> [setup|map|cleanup]");
            System.exit(2);
        }
        JobConf job = new JobConf();
        job.setMapperClass(MapperClass.class);
        /** For MapOnly jobs, the number of reducers must be explicitly set to 0. */
        job.setNumReduceTasks(0);
        /** Configure information about input and output tables. */
        InputUtils.addTable(TableInfo.builder().tableName(args[0]).build(), job);
        OutputUtils.addTable(TableInfo.builder().tableName(args[1]).build(), job);
        if (args.length == 3) {
            String options = new String(args[2]);
            /** You can specify key-value pairs in the JobConf file, and use getJobConf of the context to query the configurations in a mapper. */
            if (options.contains("setup")) {
                job.setBoolean("option.mapper.setup", true);
            }
            if (options.contains("map")) {
                job.setBoolean("option.mapper.map", true);
            }
            if (options.contains("cleanup")) {
                job.setBoolean("option.mapper.cleanup", true);
            }
        }
        JobClient.runJob(job);
    }
}

Como o código funciona

main() — configuração do job

O uso de job.setNumReduceTasks(0) é obrigatório para jobs map-only. Sem isso, o framework espera um reducer e o job falha. O InputUtils.addTable e o OutputUtils.addTable conectam as tabelas de entrada e saída ao job usando os argumentos da linha de comando.

O terceiro argumento opcional (setup, map ou cleanup) define a flag booleana correspondente no JobConf. Cada método do ciclo de vida lê sua própria flag por meio de context.getJobConf().getBoolean(...) e grava a saída apenas quando a flag é true.

setup() — executa uma vez antes do início do processamento

Grava um único registro com a chave "setup" e a contagem 1. Executa quando option.mapper.setup=true.

map() — executa uma vez para cada registro de entrada

Lê o primeiro campo de cada registro de entrada (record.get(0)) e o grava com a contagem 1. Executa quando option.mapper.map=true. Neste exemplo, o argumento map ativa este método, motivo pelo qual a saída contém duas linhas (uma para cada linha de entrada).

cleanup() — executa uma vez após o processamento de todos os registros

Grava um único registro com a chave "cleanup" e a contagem 1. Executa quando option.mapper.cleanup=true.