Introduzione ad 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 Anonymous.Apex.
Utilizzare la Developer Console per ispezionare i registri di debug.

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 qui: ti aspettiamo!

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 è:

Gestito in hosting: Apex viene salvato, compilato ed eseguito su un server, la Lightning 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 attentamente l'esecuzione eccessiva di codice applicando limiti che impediscono al codice di monopolizzare le risorse condivise.
Integrato con il database: è semplice accedere ai record e manipolarli. 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 un accesso transazionale al database, offrendo la possibilità di effettuare il rollback delle operazioni.
Facile da usare: Apex si basa sui noti idiomi di Java.
Facile da testare: Apex offre un supporto integrato per la creazione e l'esecuzione di test di unità e per la copertura del codice. Salesforce si assicura che tutto il codice Apex personalizzato funzioni come previsto eseguendo tutti i test di unità prima di qualsiasi aggiornamento della piattaforma.
Con versioni: il codice Apex personalizzato può essere salvato in base 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 Estensioni Salesforce per Visual Studio Code.

È inoltre possibile scrivere Apex e accedere alle informazioni di debug direttamente attraverso il browser, utilizzando l'interfaccia utente di Salesforce. Apri la Developer Console sotto il tuo nome o nel menu di accesso rapido ( Icona ingranaggio Setup (Imposta) ).

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:

Una lista di primitivi, sObject, oggetti definiti dall'utente, oggetti creati da classi Apex o raccolte.
Un insieme di primitivi, sObject, oggetti definiti dall'utente, oggetti creati da classi Apex o raccolte.
Una mappa da primitivo a primitivo, sObject o raccolta.

Un elenco di valori tipizzato, noto anche come enum
Classi Apex definite dall'utente
Classi Apex fornite dal sistema

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 l'invio di email e come esaminare i registri di debug.

Salvare una classe Apex

Salva la classe EmailManager nella tua organizzazione:

Apri la Developer Console sotto il tuo nome o nel menu di accesso rapido ().
Nella Developer Console, fai clic su File | New (Nuovo) | Apex Class (Classe Apex) e inserisci EmailManager come nome della classe, quindi fai clic su OK.

Sostituisci il corpo classe predefinito con l'esempio di classe EmailManager.
La classe EmailManager dispone di un metodo pubblico (sendMail()) per inviare email e utilizza metodi di messaggistica integrati nella libreria di classi Apex. Inoltre, questa classe dispone di un metodo helper privato (inspectResults()), che non può essere chiamato dall'esterno perché privato, ma può essere utilizzato solo all'interno della classe. Questo metodo helper ispeziona i risultati della chiamata di invio email e viene chiamato da sendMail().

public class EmailManager {
    // Public method
    public void sendMail(String address, String subject, String body) {
        // Create an email message object
        Messaging.SingleEmailMessage mail = new Messaging.SingleEmailMessage();
        String[] toAddresses = new String[] {address};
        mail.setToAddresses(toAddresses);
        mail.setSubject(subject);
        mail.setPlainTextBody(body);
        // Pass this email message to the built-in sendEmail method
        // of the Messaging class
        Messaging.SendEmailResult[] results = Messaging.sendEmail(
                                 new Messaging.SingleEmailMessage[] { mail });
        // Call a helper method to inspect the returned results
        inspectResults(results);
    }
    // Helper method
    private static Boolean inspectResults(Messaging.SendEmailResult[] results) {
        Boolean sendResult = true;
        // sendEmail returns a list of result objects.
        // Iterate through the list to inspect results.
        // In this class, the methods send only one email,
        // so we should have only one result.
        for (Messaging.SendEmailResult res : results) {
            if (res.isSuccess()) {
                System.debug('Email sent successfully');
            }
            else {
                sendResult = false;
                System.debug('The following errors occurred: ' + res.getErrors());
            }
        }
        return sendResult;
    }
}

Fai clic su File | Save (Salva) per salvare la classe.
NOTA: se la sintassi del codice non è corretta, viene visualizzato un errore nella scheda Problems (Problemi). Puoi usare i dettagli dell'errore per correggere il codice.

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.

Salesforce compila la classe quando viene salvata.

Chiamare un metodo per inviare un'email

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.

Nota

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

Nella Developer Console, fai clic su Debug | Open Execute Anonymous Window (Apri finestra di esecuzione anonima).
Nella finestra che si apre, inserisci quanto segue. Assicurati di sostituire "Your email address" (Il tuo indirizzo email) con il tuo indirizzo email.
```
EmailManager em = new EmailManager();
em.sendMail('Your email address', 'Trailhead Tutorial', '123 body');
```
Fai clic su Execute (Esegui).
Dovresti ricevere un'email nella tua Inbox. Controlla la tua casella email!

Ispezionare 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 sendMail(), scrive messaggi nel registro utilizzando il metodo System.debug() per indicare se l'operazione di invio dell'email è 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.

Nella Developer Console, fai clic sulla scheda Logs (Registri) e fai doppio clic sul registro più recente dell'elenco.
Seleziona Debug Only (Solo debug) per filtrare il registro in modo che vengano visualizzate solo le righe di registro relative alle istruzioni System.debug().

Vedrai il seguente messaggio nella vista del registro filtrata, ammesso che l'email sia stata inviata senza errori.

DEBUG|Email sent successfully

Nota

È anche possibile filtrare il registro di debug cercando una qualsiasi parola chiave nel campo Filter (Filtro) o selezionando una qualsiasi delle altre opzioni. Per ulteriori informazioni, vedere la Guida del controllo registri.

Chiamare un metodo statico

Poiché il metodo sendMail() 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 Developer Console, trova la scheda aperta per la classe EmailManager e modifica la prima riga della definizione del metodo sendMail() come segue (l'unica modifica è l'aggiunta della parola chiave static).
```
public static void sendMail(String address, String subject, String body) {
```
Fai clic su File | Save (Salva) per salvare la classe.
Modifica le istruzioni nella finestra Execute Anonymous (Esecuzione anonima) in modo da chiamare il metodo statico utilizzando il nome della classe.
```
EmailManager.sendMail('Your email address', 'Trailhead Tutorial', '123 body');
```
Fai clic su Execute (Esegui). Ora che questo metodo è stato eseguito, puoi controllare l'email e, facoltativamente, il registro di debug come nei passaggi precedenti.

Hai bisogno di aiuto?

Scopri di più