Skip to main content
A Trailblazer Community no Slack está agora em beta aberto. Participe e interaja em tempo real. Junte-se a nós no Slack

Introdução ao Apex

Objetivos de aprendizagem

Após concluir esta unidade, você estará apto a:

  • Descrever os principais recursos da linguagem de programação do Apex.
  • Salvar uma classe do Apex e métodos de chamada com Apex anônimo.
  • Use o Web Console para inspecionar registros de depuração.
Nota

Nota

Deseja aprender em português (Brasil)? Comece o desafio em um Trailhead Playground de português (Brasil) e use as traduções fornecidas entre parênteses para navegar. Copie e cole somente os valores em inglês porque as validações dos desafios dependem de dados em inglês. Se você não passar no desafio em sua organização de português (Brasil), recomendamos que (1) mude o local para os Estados Unidos, (2) mude o idioma para inglês, seguindo as instruções aqui, e (3) clique novamente no botão “Validar o desafio”.

Consulte o emblema Trailhead no seu idioma para saber mais sobre como aproveitar a experiência de Trailhead em outros idiomas.

Antes de começar

Estamos empolgados em acompanhá-lo em sua aventura Apex. Embora este módulo cubra informações básicas sobre a linguagem de programação, ele também aprofunda a questão, rapidamente. Se este módulo for sua primeira exposição ao Apex, recomendamos que você consulte primeiro o projeto Início rápido: Apex. Mas depois volte. Estaremos esperando por você!

O que é o Apex?

Apex é uma linguagem de programação que usa sintaxe similar à do Java e funciona como procedimentos armazenados no banco de dados. O Apex permite que os desenvolvedores adicionem lógica de negócios a eventos do sistema, tais como cliques em botões, atualizações de registros relacionados e páginas do Visualforce.

Como linguagem, o Apex é:

  • Hospedado – o Apex é salvo, compilado e executado no servidor, que é a Salesforce Platform.
  • Orientado por objetos – o Apex é compatível com classes, interfaces e herança.
  • Altamente tipificado – o Apex valida as referências aos objetos no momento da compilação.
  • Consciente dos multilocatários – como o Apex é executado em uma plataforma multilocatário, ele protege rigorosamente contra códigos sem controle através da imposição de limites. Estes limites ajudam a impedir que o código de monopolize recursos compartilhados.
  • Integrado ao banco de dados – ele acessa e manipula registros diretamente. O Apex proporciona acesso direto aos registros e seus campos, e oferece instruções e linguagens de consulta para manipular tais registros.
  • Concentrado nos dados – o Apex oferece acesso transacional ao banco de dados, permitindo que você reverta operações.
  • Fácil de usar – o Apex se baseia em linguagens Java conhecidas.
  • Fácil de testar – o Apex oferece suporte integrado à criação, execução e cobertura de código de testes de unidade.
  • Compatível com versões – é possível salvar códigos personalizados do Apex referentes a diversas versões da API.

O Apex é uma linguagem de programação baseada na nuvem

Destaques da linguagem Apex

Assim como outras linguagens de programação orientadas por objeto, o Apex é compatível com estas construções de linguagem, entre outras:

  • Classes, interfaces, propriedades e coleções (listas, mapas e conjuntos).
  • Notação de objeto e matriz.
  • Expressões, variáveis e constantes.
  • Instruções condicionais (if-then-else) e instruções de fluxo de controle (loops for e loops while).

Ao contrário das outras linguagens de programação orientadas por objeto, o Apex é compatível com:

  • Desenvolvimento na nuvem, pois o Apex é armazenado, compilado e executado na nuvem.
  • Acionadores, que são semelhantes aos acionadores dos sistemas de banco de dados.
  • Instruções de banco de dados, que permitem fazer chamadas diretas para o banco de dados e consultar linguagens a fim de consultar e pesquisar dados.
  • Transações e reversões.
  • Modificador de acesso global, que é mais permissivo do que o modificador public e permite o acesso entre namespaces e aplicativos.
  • Versões do código personalizado.

Além disso, o Apex é uma linguagem que não diferencia maiúsculas de minúsculas.

Ferramentas de desenvolvimento

Você também pode programar e depurar o Apex no computador cliente utilizando Extensões do Salesforce para Visual Studio Code. Consulte Desenvolver com facilidade usando extensões do Salesforce.

Também é possível programar Apex e acessar informações de depuração diretamente no navegador por meio da interface de usuário do Salesforce. Web Console é um ambiente de desenvolvimento integrado (IDE) moderno, leve e baseado em navegador, projetado para preencher a lacuna entre ferramentas legadas desatualizadas e ambientes de desenvolvimento com alto consumo de recursos. Para saber mais, consulte a documentação para desenvolvedor do Web Console.

Você pode abrir o Web Console no menu de acesso rápido (ícone de mecanismo de Configuração).

Web Console

Visão geral dos tipos de dados

O Apex dá suporte a vários tipos de dados, inclusive um tipo de dados específico do Salesforce, o sObject.

O Apex dá suporte aos seguintes tipos de dados.

  • Números primitivos, como números inteiros, duplos, longos, data, data/hora, string, ID, booleano e outros.
  • Um sObject, seja um sObject genérico ou específico, como uma Conta, um Contato ou MyCustomObject__c (você aprenderá mais sobre sObjects em outra unidade).
  • Uma coleção, incluindo:
    • Uma lista – uma coleção ordenada e indexada de elementos. Os elementos de uma lista podem ser de qualquer tipo de dados, incluindo tipos primitivos, coleções, sObjects, tipos definidos pelo usuário e tipos do Apex fornecidos pelo sistema (integrados).
    • Um conjunto – uma coleção não ordenada de elementos. Os elementos de um conjunto também podem ser de qualquer tipo de dados e não podem conter valores duplicados.
    • Um mapa – uma coleção de pares de chave-valor que podem ser de qualquer tipo de dados.
  • Uma lista tipificada de valores, também conhecida como enum
  • Classes do Apex definidas pelo usuário (personalizadas)
  • Classes do Apex fornecidas pelo sistema (integradas)

Coleções do Apex: Lista

As listas contêm uma coleção ordenada de dados do mesmo tipo.

As duas declarações a seguir são equivalentes. A variável colors é declarada usando a sintaxe List.

List<String> colors = new List<String>();

Como alternativa, a variável colors (cores) pode ser declarada usando a notação de matriz.

String[] colors = new List<String>();

Cultive coleções conforme necessário usando o método List.add() para adicionar novos elementos. Você pode usar a notação da matriz de colchetes para referenciar elementos existentes na coleção por índice. No entanto, você não pode usar a notação de matriz de colchetes para adicionar mais elementos.

Este exemplo mostra como adicionar elementos a uma lista, quando você cria uma e, em seguida, usar o método add() para adicionar mais elementos.

// Create a list and add elements to it in one step
List<String> colors = new List<String> { 'red', 'green', 'blue' };
// Add elements to a list after it has been created
List<String> moreColors = new List<String>();
moreColors.add('orange');
moreColors.add('purple');

Os elementos de lista podem ser lidos com a especificação de um índice entre colchetes, conhecido como notação de matriz. Além disso, você pode usar o método get() para ler um elemento de lista. Este exemplo é baseado nas listas criadas no exemplo anterior e mostra como ler elementos de lista usando um desses métodos. O exemplo também mostra como iterar sobre elementos da lista.

// Get elements from a list
String color1 = moreColors.get(0);
String color2 = moreColors[0];
System.assertEquals(color1, color2);
// Iterate over a list to read elements
System.debug('Print out the colors in moreColors:');
for(String color : moreColors) {
    // Write value to the debug log
    System.debug(color);
}

Ir além das noções básicas

O Apex dá suporte a mais dois tipos de coleção: Set e Map. Saiba mais sobre eles na seção Coleções do Guia do desenvolvedor do Apex.

Classes do Apex

Uma das vantagens das classes do Apex é a reutilização do código. Os métodos de classe podem ser chamados por acionadores e outras classes. O tutorial a seguir orienta você no processo de salvar uma classe de exemplo em sua organização, usando esta classe para atualizar descrições de contas, e inspecionar registros de depuração.

Salvar uma classe do Apex

A classe AccountProcessor tem um método público updateAccountDescriptions(). Esse método pega uma lista de contas e atualiza as respectivas descrições de acordo com o formato especificado no método auxiliar privado applyStandardFormatting(). Não é possível chamar métodos auxiliares privados externamente; eles precisam ser chamados de dentro da classe. A classe AccountProcessor também contém o método auxiliar privado inspectResults(), que inspeciona os resultados da operação de atualização do banco de dados.

Salve a classe AccountProcessor na sua organização do Trailhead.

  1. Abra o Web Console no menu de acesso rápido (ícone de engrenagem do Setup).
  2. No Web Console, pressione Ctrl+Shift+P (Windows) ou ⌘+Shift+P (macOS) para abrir a paleta de comandos.
  3. Insira SFDX: Create Apex Class e pressione Enter.
  4. Para o tipo de modelo, selecione DefaultApexClass e pressione Enter.
  5. Como nome do projeto, insira AccountProcessor e pressione Enter.
  6. Para o diretório de saída, selecione force-app/main/default/classes e pressione Enter.
  7. Substitua o corpo da classe padrão pelo exemplo da classe AccountProcessor.
public with sharing class AccountProcessor {
    /**
     * Applies a standard formatting to the descriptions of accounts in the list,
     * and updates each account.
     */
    public void updateAccountDescriptions(List<Account> acctList) {
        if (acctList == null || acctList.isEmpty()) {
            System.debug('Account list is null or empty.');
            return;
        }
        for (Account acc : acctList) {
            applyStandardFormatting(acc);
        }
        Database.SaveResult[] srList = Database.update(acctList,
false,
AccessLevel.USER_MODE);
        inspectResults(srList);
    }
    /**
     * Private helper method to handle the description formatting logic.
     */
    private static void applyStandardFormatting(Account acc) {
        String timestamp = String.valueOf(Datetime.now());
        if (String.isBlank(acc.Description)) {
            acc.Description = 'Account updated on: ' + timestamp;
        } else {
            acc.Description += ' | Last processed: ' + timestamp;
        }
    }
    /*
     * Private helper method to inspect the returned results.
     */
    private static void inspectResults(Database.SaveResult[] results) {
        for (Database.SaveResult sr : results) {
            if (sr.isSuccess()) {
                System.debug('Successfully updated account. Account ID: ' + sr.getId());
            } else {
                for (Database.Error err : sr.getErrors()) {
                    System.debug('The following error has occurred.');
                    System.debug(err.getStatusCode() + ': ' + err.getMessage());
                    System.debug('Account fields that affected this error: ' +
err.getFields());
                }
            }
        }
    }
}
  1. Para salvar sua classe, pressione Ctrl+S (Windows) ou ⌘+S (macOS).

O Salesforce compila e implanta sua classe quando você a salva.

Note

Se a sua classe contém erros, a implantação falhará quando você tentar salvá-la. Você pode ver informações sobre os erros no painel Output (Saída), na parte inferior da janela do Web Console.

Ir além das noções básicas

A classe que você acabou de salvar utiliza a programação orientada a objetos (OOP, object-oriented programming). A classe encapsula os métodos que estão relacionados ao gerenciamento de emails. Para ser um exemplo perfeito de OOP, a classe também deveria conter variáveis membro (atributos) e métodos de acessador para acessar esses atributos. No entanto, por questões de simplificação, nossa classe não inclui nada disso.

Chamar um método para atualizar a descrição de uma conta

Vamos invocar o método público. Vamos usar a execução do Apex anônimo para fazer isso. O Apex anônimo permite executar linhas de código instantaneamente e é uma maneira prática de invocar o Apex, especialmente para testar a funcionalidade. São gerados resultados de registro de depuração, como em qualquer outra execução do Apex.

Note

Há outras maneiras de invocar o Apex, por exemplo, por meio de acionadores. Falaremos mais sobre acionadores em outro módulo.

  1. No Web Console (Console da Web), pressione Ctrl+Shift+P (Windows) ou Cmd+Shift+P (macOS) para abrir a paleta de comandos.
  2. Insira SFDX: Create Anonymous Apex Script e pressione Enter.
  3. Como nome da classe, insira UpdateAccounts e pressione Enter.
  4. Para o diretório de saída, selecione scripts/apex e pressione Enter.
  5. Insira este código.
// Create new accounts
List<Account> newAccts = new List<Account>();
newAccts.add(new Account(Name='My New Account', Description='Original Description'));
newAccts.add(new Account(Name='My Second New Account'));
// Insert them into the database
try {
    insert as user newAccts;
    System.debug('Successfully inserted ' + newAccts.size() + ' accounts.');
} catch (Exception e) {
    System.debug('An error inserting the records occurred: ' + e.getMessage());
}
// Instantiate an AccountProcessor object
AccountProcessor myAcctProcessor = new AccountProcessor();
// Pass the original list to update the account descriptions
myAcctProcessor.updateAccountDescriptions(newAccts);
  1. Para salvar o script, pressione Ctrl+S (Windows) ou ⌘+S (macOS).
  2. Para executar o script, clique com o botão direito do mouse no editor de texto e selecione SFDX: Execute Anonymous Apex with Currently Open Editor (SFDX: Executar Apex anônimo com o editor atualmente aberto).
  3. No Salesforce, abra as páginas de detalhes dos registros My New Account (Minha nova conta) e My Second New Account (Minha segunda nova conta).

O campo Description (Descrição) do registro My New Account (Minha nova conta) deve ser Original Description | Last processed: 2026-01-01 00:00:00 e o campo Description (Descrição) do registro My Second New Account (Minha segunda nova conta) deve ser Account updated on: 2026-01-01 00:00:00, exceto que ambos os carimbos de data/hora refletirão a hora e a data em que você executou a transação do Apex anônima.

Ver registros de depuração

Os registros de depuração são úteis para depurar seu código. Quando os métodos do Apex são executados, as chamadas são registradas no registro de depuração. Além disso, você pode gravar suas próprias mensagens de depuração no registro para ajudar na depuração do código no caso de existirem erros. O método auxiliar inspectResults(), chamado por updateAccountDescriptions(), grava mensagens no registro usando o método System.debug() para indicar se a operação de atualização do banco de dados foi bem-sucedida ou apresentou erros. Você pode procurar estas mensagens no registro de depuração que foi gerado ao executar o método.

  1. Após executar o script UpdateAccounts em Web Console (Console da Web), abra o painel Output (Saída).
  2. Selecione Depurar apenas para filtrar o registro, para que apenas as linhas de registro das instruções System.debug() sejam exibidas.
  3. No campo filter (filtrar), na parte superior do painel Output (Saída), insira USER_DEBUG para filtrar o log de modo que apenas as linhas de log das instruções System.debug() sejam exibidas.
  4. Você também pode ver o registro de depuração no diretório .sfdx/tools/debug/logs.

Filtrar o registro de depuração em Web Console (Console da Web) para exibir mensagens de depuração

Você verá as seguintes mensagens na exibição filtrada do registro, desde que o script tenha sido executado sem erros.

DEBUG|Successfully inserted 2 accounts.
DEBUG|Successfully updated account. Account ID: {id}
DEBUG|Successfully updated account. Account ID: {id}
Note

Além disso, você pode filtrar o registro de depuração pesquisando qualquer palavra-chave no campo filter (filtrar). Para ver os tipos de registro de depuração, consulte Níveis de registro de depuração.

Chamar um método estático

Como o método updateAccountDescriptions() em nossa classe não acessa variáveis membro da classe, não é necessário que ele seja um método de instância. Vamos alterá-lo para método estático adicionando a palavra-chave static a sua declaração. Os métodos estáticos são mais fáceis de chamar do que os métodos de instância porque eles não precisam ser chamados em uma instância da classe, mas são chamados diretamente no nome da classe.

  1. Em Web Console (Console da Web), abra o arquivo de classe AccountProcessor.cls.
  2. Modifique a primeira linha da definição updateAccountDescriptions(). A única alteração é a adição da palavra-chave static.
public static void updateAccountDescriptions(List<Account> acctList) {
  1. Para salvar sua classe, pressione Ctrl+S (Windows) ou ⌘+S (macOS). A classe é reimplantada quando você salva.
  2. Abra o arquivo de script do Apex anônimo UpdateAccounts.apex.
  3. Substitua o código atual pelo código a seguir, para que o script chame o método estático no nome da classe.
// Create new accounts
// For clarity, use different account names than the ones you used previously
List<Account> newAccts = new List<Account>();
newAccts.add(new Account(Name='My Third New Account', Description='Original Description'));
newAccts.add(new Account(Name='My Fourth New Account'));
// Insert them into the database
try {
    insert as user newAccts;
    System.debug('Successfully inserted ' + newAccts.size() + ' accounts.');
} catch (Exception e) {
    System.debug('An error inserting the records occurred: ' + e.getMessage());
}
// Pass the original list to update the account descriptions
// The static method is called directly on the class
AccountProcessor.updateAccountDescriptions(newAccts);
  1. Para salvar o script, pressione Ctrl+S (Windows) ou ⌘+S (macOS).
  2. Para executar o script, clique com o botão direito do mouse no editor de texto e selecione SFDX: Execute Anonymous Apex with Currently Open Editor (SFDX: Executar Apex anônimo com o editor atualmente aberto). Agora que esse método foi executado, você pode verificar as descrições de contas atualizadas no Salesforce e, opcionalmente, o registro de depuração como nas etapas anteriores.

Recursos

Compartilhe seu feedback do Trailhead usando a Ajuda do Salesforce.

Queremos saber sobre sua experiência com o Trailhead. Agora você pode acessar o novo formulário de feedback, a qualquer momento, no site Ajuda do Salesforce.

Saiba mais Continue compartilhando feedback