Skip to main content
La Trailblazer Community su Slack è ora in beta aperta: unisciti e connettiti in tempo reale. Unisciti a noi su Slack

Iniziare a utilizzare Apex

Obiettivi di apprendimento

Al completamento di questa unità, sarai in grado di:

  • Descrivere le caratteristiche principali del linguaggio di programmazione Apex.
  • Salvare una classe Apex e chiamare metodi con Apex anonimo.
  • Utilizzare la Console Web per esaminare i registri di debug.
Nota

Nota

Stai seguendo la formazione in italiano? Inizia la sfida in un Trailhead Playground in italiano e utilizza le traduzioni fornite tra parentesi per la navigazione. Per quanto riguarda i valori da inserire, copia e incolla solo quelli in lingua inglese, perché la convalida della sfida è basata sul fatto che i dati siano in inglese. Se non superi la sfida nella tua organizzazione italiana, ti consigliamo di (1) selezionare Stati Uniti per le impostazioni internazionali, (2) selezionare Inglese per la lingua seguendo le istruzioni riportate qui e, successivamente, (3) fare nuovamente clic sul pulsante "Controlla la sfida".

Visita il badge Trailhead nella tua lingua per informazioni dettagliate su come usufruire dell'esperienza Trailhead in altre lingue.

Prima di iniziare

Siamo entusiasti di accompagnarti nella tua avventura con Apex. Questo modulo tratta le informazioni di base sul linguaggio di programmazione, ma approfondisce anche il tema in modo rapido. Se questo modulo è la tua prima esperienza con Apex, ti consigliamo vivamente di studiare prima il progetto Avvio rapido: Apex. Poi, torna su questa pagina: saremo qui ad aspettarti.

Che cos'è Apex?

Apex è un linguaggio di programmazione che utilizza una sintassi simile a quella di Java e si comporta come le stored procedure di database. Apex permette agli sviluppatori di aggiungere una logica di business agli eventi di sistema, come i clic sui pulsanti, gli aggiornamenti dei record correlati e le pagine Visualforce.

Come linguaggio, Apex è:

  • Ospitato: Apex viene salvato, compilato ed eseguito su un server, ossia Salesforce Platform.
  • Orientato agli oggetti: Apex supporta classi, interfacce ed ereditarietà.
  • Fortemente tipizzato: Apex convalida i riferimenti agli oggetti in fase di compilazione.
  • Sensibile ad ambienti multitenant: dal momento che viene eseguito su una piattaforma multitenant, Apex previene accuratamente l’esecuzione incontrollata di codice applicando limiti che impediscono al codice di monopolizzare le risorse condivise.
  • Integrato con il database: è semplice accedere ai record e modificarli. Apex offre un accesso diretto ai record e relativi campi e fornisce istruzioni e linguaggi di query per manipolare tali record.
  • Incentrato sui dati: Apex fornisce accesso transazionale al database, offrendo la possibilità di effettuare il rollback delle operazioni.
  • Facile da usare: Apex è basato su idiomi di Java ben noti.
  • Facile da testare: Apex offre supporto integrato per la creazione e l'esecuzione di test di unità e per la copertura del codice.
  • Supporto delle versioni: il codice Apex personalizzato può essere salvato associandolo alle diverse versioni dell'API.

Apex è un linguaggio di programmazione basato su cloud

Caratteristiche salienti del linguaggio Apex

Come altri linguaggi di programmazione orientati agli oggetti, questi sono alcuni dei costrutti del linguaggio supportati da Apex:

  • Classi, interfacce, proprietà e raccolte (liste, mappe e insiemi).
  • Notazione di oggetti e array.
  • Espressioni, variabili e costanti.
  • Istruzioni condizionali (if-then-else) e istruzioni di flusso di controllo (loop for e loop while).

A differenza di altri linguaggi di programmazione orientati agli oggetti, Apex supporta:

  • Sviluppo per il cloud: Apex viene memorizzato, compilato ed eseguito nel cloud.
  • Trigger, che sono simili ai trigger dei sistemi di database.
  • Istruzioni di database, che permettono di effettuare chiamate dirette al database e linguaggi di query per effettuare query e ricerche sui dati.
  • Transazioni e rollback.
  • Modificatore di accesso global, che è più permissivo del modificatore public e consente l'accesso attraverso gli spazi dei nomi e le applicazioni.
  • Controllo delle versioni del codice personalizzato

Inoltre, Apex è un linguaggio che non fa distinzione tra maiuscole e minuscole.

Strumenti di sviluppo

È possibile scrivere codice Apex ed eseguirne il debug sul computer client utilizzando le estensioni Salesforce per Visual Studio Code. Vedi Develop with Ease with Salesforce Extensions (Sviluppare facilmente con le estensioni Salesforce).

È inoltre possibile scrivere Apex e accedere alle informazioni di debug direttamente attraverso il browser, utilizzando l'interfaccia utente di Salesforce. La Console Web è un IDE (Integrated Development Environment) moderno, leggero e basato su browser, progettato per colmare il divario tra strumenti legacy ormai obsoleti e gli ambienti di sviluppo caratterizzati da un elevato overhead. Per saperne di più, consulta la documentazione per gli sviluppatori sulla Console Web.

La Console Web può essere aperta dal menu di accesso rapido (Icona ingranaggio di Setup).

Console Web

Panoramica sui tipi di dati

Apex supporta diversi tipi di dati, tra cui un tipo di dati specifico di Salesforce: il tipo di dati sObject.

Apex supporta i tipi di dati seguenti:

  • un primitivo, ad esempio Integer, Double, Long, Date, Datetime, String, ID, Boolean e altri ancora.
  • Un sObject, sia come sObject generico che come sObject specifico, ad esempio Account, Contact o MyCustomObject__c (approfondiremo gli sObject in un’unità successiva).
  • Una raccolta, tra cui:
    • Un elenco: una raccolta ordinata e indicizzata di elementi. Gli elementi dell’elenco possono essere formati da qualsiasi tipo di dati, inclusi i tipi primitivi, le raccolte, gli sObject, i tipi definiti dall’utente e i tipi Apex integrati (forniti dal sistema).
    • Un insieme: una raccolta non ordinata di elementi. Anche gli elementi di un insieme possono essere formati da qualsiasi tipo di dati e non possono contenere valori duplicati.
    • Una mappa: una raccolta di coppie chiave-valore che possono essere formate di qualsiasi tipo di dati.
  • Un elenco di valori tipizzato, noto anche come enum
  • Classi Apex definite dall’utente (personalizzate)
  • Classi Apex fornite dal sistema (integrate)

Raccolte Apex: List

Le liste contengono una raccolta ordinata di dati dello stesso tipo.

Le due dichiarazioni seguenti si equivalgono. La variabile colors viene dichiarata utilizzando la sintassi List.

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

In alternativa, la variabile colors può essere dichiarata utilizzando la notazione delle array.

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

Se necessario, puoi ampliare le raccolte utilizzando il metodo List.add() per aggiungere nuovi elementi. Per fare riferimento agli elementi esistenti nella raccolta in base all'indice, puoi usare la notazione tra parentesi quadre delle array. Tuttavia, non puoi usare la notazione tra parentesi quadre delle array per aggiungere altri elementi.

Questo esempio mostra come aggiungere elementi a un elenco quando viene creato e poi utilizzare il metodo add() per aggiungere altri elementi.

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

Gli elementi di una lista possono essere letti specificando un indice tra parentesi quadre, noto come notazione delle array. Per leggere l'elemento di un elenco, è inoltre possibile utilizzare il metodo get() . Questo esempio si basa sugli elenchi creati nell'esempio precedente e mostra come leggere gli elementi di un elenco utilizzando ciascun metodo. L'esempio mostra inoltre come eseguire l'iterazione sugli elementi della 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);
}

Oltre i concetti di base

Apex supporta altri due tipi di raccolta: Set e Map. Maggiori informazioni al riguardo sono disponibili nella sezione sulle raccolte della Apex Developer Guide (Guida per gli sviluppatori Apex).

Classi Apex

Uno dei vantaggi delle classi Apex è la possibilità di riutilizzare il codice. I metodi di classe possono essere chiamati dai trigger e da altre classi. Il tutorial riportato di seguito mostra come salvare una classe di esempio all’interno dell’organizzazione, come utilizzarla per aggiornare le descrizioni degli account e come esaminare i registri di debug.

Salvare una classe Apex

La classe AccountProcessor contiene un metodo pubblico, updateAccountDescriptions(). Questo metodo riceve un elenco di account e ne aggiorna la descrizione in base al formato specificato nel metodo helper privato applyStandardFormatting(). I metodi helper privati non possono essere chiamati dall’esterno della classe, ma devono essere chiamati dal suo interno. La classe AccountProcessor contiene anche il metodo helper privato inspectResults(), che esamina i risultati dell’operazione di aggiornamento del database.

Salva la classe AccountProcessor nella tua organizzazione Trailhead.

  1. Apri la Web Console (Console Web) nel menu di accesso rapido (Icona ingranaggio di Imposta).
  2. Nella Web Console (Console Web), premi Ctrl+Maiusc+P (Windows) o ⌘+Maiusc+P (macOS) per aprire il riquadro comandi.
  3. Inserisci SFDX: Create Apex Class (SFDX: Crea classe Apex) e premi Invio.
  4. Seleziona DefaultApexClass come tipo di modello e premi Invio.
  5. Inserisci AccountProcessor come nome della classe e premi Invio.
  6. Seleziona force-app/main/default/classes come directory di output e premi Invio.
  7. Sostituisci il corpo predefinito della classe con l’esempio della 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. Per salvare la classe, premi Ctrl+S (Windows) o ⌘+S (macOS).

Al momento del salvataggio, Salesforce compila la classe.

Note

Se la classe contiene errori quando tenti di salvarla, la distribuzione non riuscirà. Puoi visualizzare le informazioni sugli errori nel riquadro Output in fondo alla finestra della Web Console (Console web).

Oltre i concetti di base

La classe appena salvata utilizza la programmazione orientata agli oggetti (OOP, Object Orientend Programming). La classe incapsula i metodi relativi alla gestione delle email. Per essere un esempio perfetto di OOP, la classe dovrebbe contenere anche variabili membro (attributi) e metodi della funzione di accesso a tali attributi, ma per semplicità la nostra classe non li ha.

Chiamare un metodo per aggiornare la descrizione di un account

Chiamiamo il metodo pubblico. Allo scopo utilizzeremo l'esecuzione Apex anonima. L'esecuzione Apex anonima consente di eseguire righe di codice in tempo reale ed è un modo pratico per chiamare codice Apex, soprattutto per testare le funzionalità. I risultati del registro di debug vengono generati come per qualsiasi altra esecuzione di Apex.

Note

Esistono altri modi di chiamare codice Apex, ad esempio attraverso i trigger. Approfondiremo i trigger in un altro modulo.

  1. Nella Web Console (Console Web), premi Ctrl+Maiusc+P (Windows) o Cmd+Maiusc+P (macOS) per aprire il riquadro comandi.
  2. Inserisci SFDX: Create Anonymous Apex Script (SFDX: Crea script Apex anonimo) e premi Invio.
  3. Inserisci UpdateAccounts come nome della classe e premi Invio.
  4. Seleziona scripts/apex come directory di output e premi Invio.
  5. Inserisci il codice seguente.
// 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. Per salvare lo script, premi Ctrl+S (Windows) o ⌘+S (macOS).
  2. Per eseguire lo script, fai clic con il pulsante destro del mouse nell’editor di testo e seleziona SFDX: Execute Anonymous Apex with Currently Open Editor (SFDX: Esegui Apex anonimo con l’editor attualmente aperto).
  3. In Salesforce, apri le pagine dei dettagli dei record My New Account (Il mio nuovo account) e My Second New Account (Il mio secondo nuovo account).

Il campo Description (Descrizione) di My New Account (Il mio nuovo account) dovrebbe contenere Original Description | Last processed: 2026-01-01 00:00:00 (Descrizione originale | Ultima elaborazione: 2026-01-01 00:00:00) e il campo Description (Descrizione) di My Second New Account (Il mio secondo nuovo account) dovrebbe contenere Account updated on: 2026-01-01 00:00:00 (Data aggiornamento account: 2026-01-01 00:00:00), fatta eccezione per il fatto che in entrambi i casi il timestamp rifletterà la data e l’ora in cui hai eseguito la transazione Apex anonima.

Esaminare i registri di debug

I registri di debug sono utili per effettuare il debug del codice. Quando i metodi Apex vengono eseguiti, le chiamate vengono registrate nel registro di debug. Inoltre, puoi scrivere i tuoi messaggi di debug nel registro e questo ti aiuta a effettuare il debug del codice in caso di errori. Il metodo helper inspectResults(), chiamato da updateAccountDescriptions(), scrive dei messaggi nel registro utilizzando il metodo System.debug() per indicare se l’operazione di aggiornamento del database è andata a buon fine o se si sono verificati degli errori. Puoi cercare questi messaggi nel registro di debug generato durante l'esecuzione del metodo.

  1. Dopo aver eseguito lo script UpdateAccounts nella Web Console (Console Web), apri il riquadro Output.
  2. Seleziona Debug Only (Solo debug) per filtrare il registro in modo che vengano visualizzate solo le righe di registro relative alle istruzioni System.debug().
  3. Nel campo Filter (Filtro) visualizzato nella parte superiore del riquadro Output, inserisci USER_DEBUG per filtrare il registro in modo da visualizzare solo le righe relative alle istruzioni System.debug().
  4. Puoi anche visualizzare il registro di debug nella directory .sfdx/tools/debug/logs.

Filtro del registro di debug nella Web Console (Console Web) che visualizza i messaggi di debug

Nella visualizzazione del registro filtrata saranno visualizzati i messaggi seguenti, a condizione che lo script sia stato eseguito senza errori.

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

Puoi anche filtrare il registro di debug cercando qualsiasi parola chiave utilizzando il campo Filter (Filtro). Per informazioni sui tipi di eventi riportati nel registro, vedi Livelli del registro di debug.

Chiamare un metodo statico

Poiché il metodo updateAccountDescriptions() della nostra classe non accede a variabili membro della classe, non è necessario che sia un metodo di istanza. Cambiamolo in un metodo statico aggiungendo la parola chiave static alla dichiarazione. I metodi statici sono più facili da chiamare rispetto ai metodi di istanza perché non devono essere chiamati su un'istanza della classe ma vengono chiamati utilizzando direttamente il nome della classe.

  1. Nella Web Console (Console web), apri il file della classe AccountProcessor.cls.
  2. Modifica la prima riga della definizione di updateAccountDescriptions(). L’unica modifica consiste nell’aggiunta della parola chiave static.
public static void updateAccountDescriptions(List<Account> acctList) {
  1. Per salvare la classe, premi Ctrl+S (Windows) o ⌘+S (macOS). Al momento del salvataggio, la classe viene ridistribuita.
  2. Apri il file dello script Apex anonimo UpdateAccounts.apex.
  3. Sostituisci il codice presente nel file con quello riportato di seguito, in modo che lo script chiami il metodo statico utilizzando il nome della 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. Per salvare lo script, premi Ctrl+S (Windows) o ⌘+S (macOS).
  2. Per eseguire lo script, fai clic con il pulsante destro del mouse nell’editor di testo e seleziona SFDX: Execute Anonymous Apex with Currently Open Editor (SFDX: Esegui Apex anonimo con l’editor attualmente aperto). Ora che questo metodo è stato eseguito, puoi controllare le descrizioni degli account aggiornate in Salesforce e, facoltativamente, il registro di debug come descritto nei passaggi precedenti.

Risorse

Condividi il tuo feedback su Trailhead dalla Guida di Salesforce.

Conoscere la tua esperienza su Trailhead è importante per noi. Ora puoi accedere al modulo per l'invio di feedback in qualsiasi momento dal sito della Guida di Salesforce.

Scopri di più Continua a condividere il tuo feedback