Oracle Application Express

Oracle Application Express software
Logo
Genere
Sviluppatore	Oracle Corporation
Data prima versione	2004
Ultima versione	23.2 (Novembre 17, 2023)
Sistema operativo
Linguaggio	PL/SQL
Licenza	licenza proprietaria (licenza non libera)
Sito web	apex.oracle.com/

Oracle Application Express (APEX) è un framework sviluppato da Oracle, pensato per lo sviluppo di siti web data-oriented e basato sull'infrastruttura fornita dal database Oracle.

Salesforce APEX è tutto ciò che segue: un linguaggio OOP (programmazione orientata agli oggetti) molto simile a Java per lo sviluppo rapido di applicazioni web.

Descrizione

La tecnologia Apex in Salesforce è una tecnologia che consente il building di applicazioni web in modo davvero rapidissimo. Tale linguaggio e le API sono fornite nativamente nel CRM Salesforce in piattaforma PaaS (Platform as a Service) chiamata Force.com. La piattaforma Force.com è inclusa nell'org Salesforce e permette l'implementazione del codice Apex sia in un ambiente dev(di sviluppo) chiamato Develop Console incluso o separatamente in un IDE(Integrated Development Environment) come Eclipse, Visual Studio code ed altri mediante l'aggiunta del plugin Force.com IDE. L'approccio di sviluppo è chiamato RAD(Rapid application Development) come per fare un paragone avviene con le pagine web costruite medianti le tecnologie JAVA EE, vedi jsf o jsp.

Il codice Apex è completamente memorizzato, compilato ed eseguito in Cloud pertanto non necessita di alcuna risorsa in locale come framework ecc. Il codice viene eseguito in piattaforma Force.com o Lightning a seconda della tecnologia utilizzata. La sintassi dell'Apex è JAVA like tanto da considerarlo un derivato di Oracle Java, anche se ci sono molte differenze e sicuramente a vantaggio dell'Apex oltre al completo uso in Cloud abbiamo sicuramente un modo di performare il manage dei dati negli oggetti del Database sicuramente molto più efficiente di qualsiasi altra tecnologia grazie alle API fornite dal linguaggio. In pratica il mappaggio dell'ORM che con altre tecnologie è realizzabile per mezzo di framework come Hibernate ed eclipseLink per Java con svariate righe di codice di logica applicativa qui in Apex è pressoché immediato e realizzato con semplici statement come se le tabelle del database e gli oggetti gestiti dall'ambiente di sviluppo fossero già mappati.

Caratteristiche

• completamente su cloud in quanto il codice viene salvato, compilato ed eseguito su server salesforce;
• supporto alla programmazione OOP con interfacce, classi ed ereditarietà;
• Multi-Utente;
• Integrato con Database Salesforce;
• Facile da usare (ha sintassi come il Java);
• Facile da testare;
• Supporta il versionamento delle API;

La piattaforma Lightning è un framework su server che permette la compilazione, memorizzazione ed esecuzione di codice Apex.

Caratteristiche del linguaggio

• Blob: collezione di dati binari salvati in un solo oggetto. Puoi trasformare questo tipo a String e viceversa.
• Boolean: true o false valore su singolo bit che descrive una condizione booleana.
• Decimal: numero decimale con punto.
• Double: Numero con la virgola a 64 bit.
• Id:ogni insieme di caratteri di lunghezza 18, se la lunghezza è inferiore viene portato a 18.
• Integer: intero a 32 bit.
• Long: intero su 64 bit.
• Date: formato data.
• Datetime: formato data e tempo.
• Object.
• String
• sObject.

Array

Il linguaggio ci mette a disposizione gli array che sono vettori contenenti elementi sia di tipo primitivo che oggetti ma ogni array rappresenta sempre un elenco di tipi omogenei.

Esempio come vediamo di seguito io posso dichiarare un array di stringhe e aggiungerne di nuove ma non posso aggiungergli un tipo diverso dal String.

String[] arrayString ; //dichiarazione
arrayString = new String[]();
//se invece conosco già la size il contenuto posso anche inizializzarlo in fase di instanziazione nel seguente modo.
arrayString = new String[4]{ 'guardate', 'come istanzio', 'questo array', 'di String'};

per l'accesso in lettura o scrittura distruttiva poi basterà usare uno dei loop che più avanti vi mostrerò.

Classi

Ora andiamo a vedere un esempio per comprendere meglio i semplici concetti visti sopra:

//sintassi dichiarazione classe
public class myFirstClassApex {
    Double weight = 84.90;
    Integer age = 37;
    Boolean married = false;
    String name = "Generoso";
    Integer idPearson = 123;
}

Collections

Troviamo in Apex le collezioni di oggetti seguenti:

List (collezione)

List<Integer> distance = new List<Integer>();
//operazioni basiche add, get, set, clear l’accesso avviene con indice...

Esempio:

distance.add(100);
distance.get(0);
distance.set(0,200);

//cancella tutto
distance.clear();

// ordinamento
distance.sort();

Set (Collezione)

Set<Double> setdistance = new Set<Double>();
// non ammette duplicati, le operazioni sono add, remove ecc..

Esempio:

setdistance.add(20);

setdistance.add(200);

setdistance.add(100);

setdistance.remove(20);

setdistance.size();

setdistance.clear();

setdistance.contains(20);

Map (Collezione)

Map<Id,String> myMap = new Map<Id,String>();
// è una coppia chiave valore

La mappa può essere inizializzata nel seguente modo:

Map<String,String> myMap = new Map<String,String>{"name"=>"Generoso", "Matter" => "Apex programming" }

Le operazioni principali sono get e put come nel seguente esempio:

myMap.put('job', 'employee');
myMap.get('job');

Costrutti condizionali

I costrutti decisionali sono:

{if-else} , {switch}.

if (condizione booleana è true){
    esecuzione di una lista di statements;
}
else{ 
    lista ancora di actions;
}

Ad esempio se mia moglie è incinta io voglio festeggiare altrimenti voglio solo bere latte:

// my_wife _state è una stringa.
if (my_wife_state == 'pregnant') {
    word = "urrà Andiamo al mio pub preferito!";
}
else {
    word = "Noo cavolo mi bevo una bottiglia di latte!";
}

System.debug(word);

Costrutti Iterativi

Per sviluppare nel linguaggio abbiamo poi necessità dei costrutti iterativi che sono:

• while
• Do-While
• For

Esempio for:

for (int counter = 0; counter < distance.size(); counter++)
System.debug(distance.get(counter));

//oppure ancora for

for (String myWord: arrayString) { 
    if(myWord.equals('guardate')
        System.debug('This is positions index zero');
}

// while

Integer counter = 0;

while (counter < distance.size()) {
    System.debug(distance.get(counter));
    counter++;
}

// do while

Integer counter = 0;

do {
    System.debug(distance.get(counter));
    counter++;
}
while(counter < distance.size());

Ricapitolando nel linguaggio Apex esistono le classi (I tipi), i trigger (una o più actions generate a seguito di un evento, ad esempio l’inserimento di un record e queste actions possono essere eseguite prima o dopo l’inserimento, un aggiornamento o una cancellazione, troviamo i tipi primitivi (Integer, Double ecc…), le interfacce, le classi sharing o without sharing.

I Triggers

Quando parliamo di trigger ci riferiamo ad uno script di codice Apex realizzabile in più modi da piattaforma Salesforce il quale abilita l'utente ad eseguire delle Actions customizzate prima o dopo il verificarsi di eventi, lo script è autonomo e la parola richiama senza ombra di dubbio i trigger usati nei database(concetto analogo). Gli eventi che possono scatenare il trigger sono i parametri del trigger stesso e sono elencati di seguito:

• before insert;
• before update;
• before delete;
• after insert;
• after update;
• after delete;
• after undelete;

Per gestire gli attributi dei record oggetto del trigger si usano delle variabili speciali chiamate di contesto, una delle quali è specificata nell'esempio dopo. Le variabili di contesto sono tutte in seguito:

• isBefore: restituisce un valore booleano pari a vero se il trigger esaminato scatta prima di un evento, falso altrimenti;
• isAfter: restituisce vero se il trigger esaminato scatta dopo l'accurarsi di evento;
• isInsert: vero se è un inserimento di record.
• isUpdate: vero se aggiornamento di record;
• isDelete: vero se l'evento è una cancellazione di record;
• isUndelete: vero se l'evento è un ripristino di record cancellati;
• isExecution: se il contesto di esecuzione è trigger e non per esempio web service;
• new: restituisce una List<recordName> e si usa solo per insert, update e undelete e i record restituiti possono solo essere modificati in before;
• old: restituisce una lista del tipo List<recordName> listaName e si usa solo per update e delete trigger;
• newMap: restituisce una list di ID dei nuovi recordsm disponibile per i triggers before update, after update, after insert e after undelete;
• oldMap: come prima ma dei record prima dell'accurarsi dell'evento, disponibile per update e delete trigger.
• size: restituisce List.size();

Vediamolo ora da vicino in che modo esso viene scatenato.

// Codice trigger
trigger triggerNameIdentificator on recordType(before insert, after insert, before update, after update, before delete, after delete) {
    for(recordType variableSupport: Trigger.New) {
        if(variableSupport.fieldName == 'patternChoosedByMe') {
            System.debug('Set Off any Actions in this block ');
        }
    }
}

Per definire variabili e costanti, abbiamo il contesto statico legato alla classe e molto altro.

Salesforce Database

La Potenza di questo linguaggio risiede nella possibilità di compilare, salvare e eseguire tutto on cloud su server Salesforce in piattaforma Lightning, esso quindi non richiede spazio in memoria ne installazioni di software oltre al grande beneficio che permette la costruzione di applicazioni con connessione nativa al database Oracle che si concretizza con invocazione diretta di script SOQL o SOSL. Ogni interrogazione e modifica del modello dati avviene per mezzo di un linguaggio DML(Data Manipulation Language) i cui statement sono i seguenti:

• insert
• update
• upsert
• delete
• undelete

La gestione dei record nel database può avvenire o per mezzo del DML solo o mediante l'oggetto Database. Un semplicissimo esempio statement DML lanciato senza l'uso dell'oggetto database è il seguente:

insert new Account(Name='accountName');

Le query vengono performate per mezzo di due linguaggi di interrogazione il Salesforce Object Query Language(SOQL) e il Salesforce Object Search Language(SOSL). Le differenze sostanziali sono che il primo è usato per query su un solo tipo di tabella e non ammette interrogazioni troppo complesse come la join ma è più usato mentre il secondo è usato per recuperare dati da più record contemporaneamente e supera le limitazioni dell'altro quando non si ha certezza sui campi da recuperare e i dati sono più tabelle. Con SOQL le command sono un sottoinsieme dell'SQL ma performate per sole SELECT di lettura che non ammette il simbolo jolly '*' mentre inserimenti, aggiornamenti e cancellazioni vengono realizzati solo pe rmezzo di DML puro. In SOSL le query sono delle FIND che si scostano dalla sintassi SQL e usate per il retrieve(recupero) di dati da più tabelle in contemporaneo.

Per esempio le query Select per leggere nel database i campi della tabella persone è così:

person[] persons = [SELECT * FROM person];
// array di oggetti del tipo person.

Voci correlate

• Salesforce.com

Collegamenti esterni

• Apex Developer Guide, su developer.salesforce.com.