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.
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.

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 modificatorepublice 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 (
).

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.
- Apri la Web Console (Console Web) nel menu di accesso rapido (
).
- Nella Web Console (Console Web), premi Ctrl+Maiusc+P (Windows) o ⌘+Maiusc+P (macOS) per aprire il riquadro comandi.
- Inserisci
SFDX: Create Apex Class(SFDX: Crea classe Apex) e premi Invio.
- Seleziona DefaultApexClass come tipo di modello e premi Invio.
- Inserisci
AccountProcessorcome nome della classe e premi Invio.
- Seleziona force-app/main/default/classes come directory di output e premi Invio.
- 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());
}
}
}
}
}- Per salvare la classe, premi Ctrl+S (Windows) o ⌘+S (macOS).
Al momento del salvataggio, Salesforce compila la classe.
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.
- Nella Web Console (Console Web), premi Ctrl+Maiusc+P (Windows) o Cmd+Maiusc+P (macOS) per aprire il riquadro comandi.
- Inserisci
SFDX: Create Anonymous Apex Script(SFDX: Crea script Apex anonimo) e premi Invio.
- Inserisci
UpdateAccountscome nome della classe e premi Invio.
- Seleziona scripts/apex come directory di output e premi Invio.
- 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);- Per salvare lo script, premi Ctrl+S (Windows) o ⌘+S (macOS).
- 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).
- 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.
- Dopo aver eseguito lo script UpdateAccounts nella Web Console (Console Web), apri il riquadro Output.
- Seleziona Debug Only (Solo debug) per filtrare il registro in modo che vengano visualizzate solo le righe di registro relative alle istruzioni
System.debug().
- Nel campo Filter (Filtro) visualizzato nella parte superiore del riquadro Output, inserisci
USER_DEBUGper filtrare il registro in modo da visualizzare solo le righe relative alle istruzioniSystem.debug().
- Puoi anche visualizzare il registro di debug nella directory .sfdx/tools/debug/logs.

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}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.
- Nella Web Console (Console web), apri il file della classe
AccountProcessor.cls.
- Modifica la prima riga della definizione di
updateAccountDescriptions(). L’unica modifica consiste nell’aggiunta della parola chiavestatic.
public static void updateAccountDescriptions(List<Account> acctList) {- Per salvare la classe, premi Ctrl+S (Windows) o ⌘+S (macOS). Al momento del salvataggio, la classe viene ridistribuita.
- Apri il file dello script Apex anonimo
UpdateAccounts.apex.
- 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);- Per salvare lo script, premi Ctrl+S (Windows) o ⌘+S (macOS).
- 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
- Apex Developer Guide: Introducing Apex (Guida per gli sviluppatori Apex: Introduzione ad Apex)
- Apex Developer Guide: Loop (Guida per gli sviluppatori Apex: Loop)
- Salesforce Developers: Use Anonymous Apex (Utilizzare un’esecuzione Apex anonima)
- Web Console: Debug Apex Code (Eseguire il debug del codice Apex)
