Nel sviluppo delle applicazioni web moderne le parole REST e API sono ormai termini che si usano spesso e non escludo che anche tu abbia avuto a che farci.
In effetti, l’approccio allo sviluppo di applicazioni basato sui microservizi è una tendenza ormai consolidata tant’è che ormai tutti le piattaforme più famose mettono a disposizione degli sviluppatori decine di librerie che possono essere utilizzate per integrare le proprie applicazioni.
Vuoi che il tuo CRM invii ai clienti dei messaggi automatici su WhatsApp con offerte speciali e personalizzate?
Oppure, desideri collegare il tuo ERP a Shopify per aggiornare in modo automatico le disponibilità dei prodotti?
Oggi tutto questo è possibile grazie all’utilizzo delle API REST messe a disposizione proprio da questi sistemi.
Anche il database Oracle nasconde (per così dire) una tecnologia che permette agli sviluppatori di creare e pubblicare API RESTful e in questo articolo desidero parlarti proprio di questo.
IN QUESTO ARTICOLO
Parliamo di ORDS
ORDS è una applicazione Java che consente agli sviluppatori con competenze di linguaggio SQL e gestione del database di sviluppare interfacce API RESTful.
Senza rischiare di scendere troppo nei dettagli tecnici, possiamo dire che grazie ad ORDS puoi creare dei web services RESTful che possono:
- eseguire delle query sul database e restituire in output i dati, generalmente organizzati in un documento in formato JSON (ma vedremo che possiamo fare qualcosa di più..)
- eseguire delle vere e proprie operazioni sul database come, ad esempio, l’inserimento e la modificare dei record in una tabella oppure l’esecuzione di store procedures PL-SQL.
Se hai già esperienza nello sviluppo dei web services, in particolar modo con ORDS, probabilmente saprai già molte delle cose che andrò a spiegare.
Invece, se sei alle prime armi e non sai bene come muoverti, penso che questo articolo ti sarà utile.
Puoi considerarlo un piccolo vademecum che puoi tenere sempre con te tutte le volte che ti chiedono di creare un web service che deve eseguire qualche tipo di operazione all’interno del database Oracle.
Cosa sono le API RESTful
RESTful API è una interfaccia utilizzata da due applicazioni per scambiare tra di loro informazioni.
Al giorno d’oggi l’utilizzo di queste interfacce è abbastanza diffuso perché consentono alle applicazioni di comunicare con altre applicazioni.
Facciamo un esempio.
Supponiamo che una azienda abbia bisogno di creare all’interno del proprio sito web, magari realizzato in WordPress, un e-commerce.
Una necessita, direi abbastanza normale, potrebbe essere quella di collegare il sito web ad una applicazione di gestione degli ordini di vendita per far si che quando un visitatore esegue un acquisto tramite il sito venga automaticamente generato un ordine di vendita.
Se ci pensi, al giorno d’oggi necessità di questo tipo non sono poi così rare e sapere come funzionano le API RESTful è ormai diventato qualcosa di imprescindibile.
Gli sviluppatori creano e pubblicano API così che altre applicazioni possano comunicare con le proprie programmaticamente.
Ad esempio, la nostra applicazione per la gestione degli ordini di vendita dovrebbe esporre una o più API RESTful che permettono ad altre applicazioni (che chiameremo Client) di:
- vedere l’elenco dei prodotti a listino
- consultare i dettagli di uno specifico prodotto
- inserire un ordine di vendita
- modificare un ordine di vendita
Nel seguito di questa guida ti mostrerò come creare una API RESTful che fa tutte queste cose.
Come funzionano le API RESTful
Le API REST comunicano tramite richieste HTTP per eseguire funzioni di database standard come la creazione, la lettura, l’aggiornamento e l’eliminazione di record all’interno di una tabella.
Questo insieme di operazioni è noto anche come CRUD, acronimo di create, read, update e delete.
Ad esempio, una API REST utilizzerà una richiesta GET per richiamare un record di una tabella (chiamato in gergo risorsa), una richiesta POST per creare un nuovo record, una richiesta PUT per aggiornare un record e una richiesta DELETE per eliminarlo.
Come fa il server a capire quale risorsa deve essere elaborata e quale tipo di operazione fare?
Il server è in grado di capire quale risorsa deve essere elaborata utilizzando l’URL, che viene chiamato anche endpoint.
Ad esempio, l’URL per recuperare tutti i prodotti in vendita si può usare questo endpoint
https://myserver/products/Quando un client desidera accedere ad una risorsa specifica (ad esempio i dettagli di uno specifico prodotto) è necessario che passi al server un parametro (ad esempio il suo id).
I parametri possono essere passati sia nell’URL oppure nell’HEADER della richiesta HTTP (vedremo tra poco cosa significa)
https://myserver/products/:idI metodi indentificano i tipi di operazione che possono essere eseguiti suoi dati sono quelli che abbiamo già citato:
- GET: usata per accedere ad una risorsa
- POST: usata per accedere creare una nuova risorsa
- PUT: usata per aggiornare i dati di una risorsa esistente
- DELETE: usata per eliminare la risorsa
Come si riflette tutto ciò quando si lavora con ORDS e con il database Oracle?
Il client, chiamando un URI, esegue un comando REST che viene interpretato da ORDS con uno specifico comando SQL (Map & Bind).
Il mapping tra i verbi REST e le operazioni che esegue il database sono riportate nella seguente tabella:
| Comando REST | Comando SQL |
|---|---|
| GET | SELECT |
| POST | INSERT |
| PUT | UPDATE |
| DELETE | DELETE |
Una API REST ben progettata è simile ad un sito web in esecuzione in un browser web con funzionalità HTTP integrate.
Di seguito i passaggi generali per qualsiasi chiamata REST API:
- Il Client invia una Richiesta al server usando le specifiche dell’API.
- Il Server autentica il Client e conferma che ha il diritto di effettuare la Richiesta.
- Il Server riceve la Richiesta ed esegue l’operazione richiesta.
- Il Server risponde al Client tramite una Risposta che rivela se la Richiesta è stata elaborata correttamente. La Risposta include inoltre qualsiasi informazione richiesta dal Client.
ORDS RESTful Data Services in Oracle APEX
ORDS e APEX non sono strettamente correlati, nel senso che per usare ORDS non è necessario usare APEX.
Potresti sviluppare web services basati su ORDS usando anche SQL Developer.
Tuttavia, Oracle APEX mette a disposizione una console di amministrazione studiata proprio per aiutare gli sviluppatori che creano applicazioni a gestire e mantenere anche i web services.
Adesso ti spiegherò come usare questa console.
Come attivare ORDS RESTful Data Services
Quando crei un nuovo WORKSPACE in Oracle APEX i servizi ORDS non sono attivi, quindi la prima cosa da fare è attivarli.
- Collegati al Workspace
- Clicca su SQL Workshop > RESTful Services
- Se i servizi RESTful non sono stati attivati in precedenza (in tal caso non devi fare nulla), dovresti vedere questo messaggio: Schema not registered with ORDS
- Clicca sul pulsante Register Schema with ORDS
- Lascia i parametri di default e premi Save Schema Attributes
- La procedura dovrebbe completarsi abbastanza velocemente con questo messaggio di conferma
Come disattivare ORDS RESTful Data Services
Sempre dalla RESTful Console, qualora tu ne abbia bisogno, puoi disattivare i servizi RESTful.
Tieni bene presente a mente che questa operazione eliminerà tutti i servizi web che hai costruito ed è irreversibile quindi.. fai attenzione!
- Accedi alla RESTful Console e clicca De-Register Schema from ORDS
- Conferma cliccando De-Register Schema.
- Messaggio di conferma
Come esportare ed importare i servizi RESTful
Quando si sviluppano applicazioni web è buona norma avere una ambiente dedicato agli sviluppi ed uno destinato all’utilizzo da parte degli utenti finali.
Installare una applicazione da un ambiente all’altro è una operazione abbastanza facile da fare grazie alle funzionalità di export/import che sono disponibili nell’APP Builder.
Una funzionalità simile è disponibile anche per i servizi rest.
- Per esportare la definizione di uno o più servizi REST accedi alla RESTful Console e clicca su Export
- Seleziona il servizio che vuoi esportare. L’opzione All Services esporta tutti i servizi che sono stati registrati.
- Quando hai fatto clicca Export.
- Oracle APEX genererà uno Script SQL che contiene tutta la definizione dei servizi
- Per importare i servizi in un’altra istanza APEX accedi alla RESTful Console dell’istanza di destinazione e clicca Import
- Specifica il file da importare e premi Import
Come configurare un Modulo REST in APEX
Il nostro obiettivo è quello di creare una API RESTful che ci permetta di integrare la nostra applicazione di gestione ordini con un e-commerce.
Questa API dovrebbe consentire diverse operazioni come la possibilità di poter inserire un nuovo ordine di vendita e, ancor prima, la possibilità di interrogare il listino prodotti.
Il primo esercizio che faremo sarà quello di creare le tabelle PRODUCTS, CUSTOMERS e ORDERS
-- create tables
create table products (
id number generated by default on null as identity
constraint table_products_id_pk primary key,
sku varchar2(12 char),
description varchar2(150 char),
unit_price number
);
create table customers (
id number generated by default on null as identity
constraint customers_id_pk primary key,
name varchar2(50 char),
address varchar2(150 char)
)
;
create table orders (
id number generated by default on null as identity
constraint orders_id_pk primary key,
customer number,
product number,
quantity number
)
;
-- insert products data
insert into products (id, sku, description,unit_price) values (1, 'ITM001', 'Product 1', 50);
insert into products (id, sku, description,unit_price) values (2, 'ITM002', 'Product 2', 15);
insert into products (id, sku, description,unit_price) values (3, 'ITM003', 'Product 3', 75);
-- insert customers data
insert into customers (id, name, address) values (1, 'Gricelda Luebbers', '3 Hambleton Blvd');
insert into customers (id, name, address) values (2, 'Dean Bollich', '303 Casasana Street');
insert into customers (id, name, address) values (3, 'Milo Manoni', '755 Greenslide Ave');Creiamo un modulo, ossia il contenitore all’interno del quale andremo a definire i vari servizi esposti dalla nostra API.
- Accedi alla Console RESTful di Oracle APEX e clicca Modules
- Clicca Create Module
- Inserisci le informazioni richieste e poi premi Create Module.
- Module Name: nome del modulo RESTful. Deve essere univoco.
- Base Path: è una stringa case sensitive utilizzata per accedere al servizio RESTful. Il Base Path viene utilizzato per costruire l’URI del servizio e deve essere univoco all’interno dello schema.
- Is Published: flag che permette di attivare o disattivare il modulo REST
- Pagination Size: numero di record restituiti da una chiamata singola.
- Il modulo è stato creato e viene aggiunto a quelli già esistenti
Per completare questa prima parte dobbiamo definire dei Resource Template.
I Resource Template sono il modo attraverso il quale puoi raggruppare le URI che identificano le varie risorse (prodotti, ordini, ecc) manipolate dalle API REST e associarle a un particolare modulo.
- Sempre dalla schermata del modulo, clicca su Create Template
- Inserisci il nome del template nel campo URI Template e premi Create Template per completare l’operazione.
- Il Resource Template è stato creato ed aggiunto al modulo
Come configurare un Metodo GET
Creiamo un Metodo GET che interroghi la tabella PRODUCTS e che generi una Response contenente tutti i prodotti che è possibile acquistare tramite l’e-commerce.
- Dalla schermata del Resource Template vai alla sezione Resource Handlers e clicca su Create Handler
- Specifica il metodo REST da implementare (GET) e il tipo di sorgente (Collection Query)
- Inserisci nel campo Source la Query SQL e premi Create Handler
select id, sku, description, unit_price
from products- L’URL che trovi nel campo Full URL è l’endpoint del servizio che dovrà essere usato dalle applicazioni che vogliono accedere al listino prodotti.
Per provare i servizi web ci sono sono doversi strumenti. Uno dei più famosi è Postman.
- Registrati gratuitamente al servizio e creare una nuova Collection e successivamente una Request di tipo GET.
- Inserisci nella Request l’URL l’endpoint del servizio esposto da ORDS e premi Send
Il risultato che dovresti ottenere è una Response in formato JSON contenente i record estratti dalla query SQL che abbiamo inserito nell’Handler
Come configurare un Metodo GET con Parametri
Come forse avrai notato, nell’esempio che abbiamo appena fatto il metodo GET non aveva parametri in ingresso.
Tuttavia è abbastanza frequente che le API REST debbano ricevere dei parametri in input per eseguire le operazioni più complesse.
Uno dei modi per passare i parametri è direttamente nell’URL.
- Accedi alla schermata del modulo e crea un nuovo Resource Template
- Nel campo URI Template inserisci la stringa products/:id
- Crea un Handler GET con Source Type=Collection Query
select id, sku, description, unit_price
from products
where id = :id
Inserendo nell’URL l’identificativo del prodotto specifico al posto della stringa :id è possibile visualizzare i dettagli del singolo record.
Quello visto non è l’unico modo attraverso il quale possiamo definire in ORDS i parametri di una API REST.
A tal proposito costruiamo un metodo GET che effettua una ricerca sui prodotti.
- Accedi alla schermata del modulo e crea un nuovo Resource Template stavolta senza indicare nessun parametro nell’URL
- Crea un Handler GET con Source Type=Collection Query
select id, sku, description, unit_price
from products
where instr(trim(upper(description)),trim(upper(:searchstr))) >0- Vai alla sezione Parameters dell’Handler e definisci il parametro searchstr
- Name: searchstr
- Bind Variable: searchstr
- Access Method: IN
- Source Type: URI
- Data Type: STRING
Per verificare il funzionamento di questo servizio dovrai appendere all’URI la stringa
?searchstr=<stringa di ricerca> dove
- searchstr è il parametro da passare nell’URI
- <stringa di ricerca> è il valore del parametro
Quindi se volessi cercare i prodotti che nella descrizione contengono la parola chiave ‘Prodotto 1’ effettuerò una chiamata all’API REST fatta così:
https://<myserver>/ords/appin5minuti/ecommerce/searchproducts?searchstr=Product%201Come configurare un Metodo POST
Il metodo POST si differenza da GET in quanto i parametri della richiesta non vengono passati direttamente nell’URL.
Caso d’uso abbastanza comune di una richiesta in POST è una form che invia dati personali, come ad esempio una form di registrazione.
Creiamo un metodo POST per inserire un nuovo record nella tabella ORDINI.
Il servizio accetterà tre parametri in ingresso:
- L’identificativo del cliente
- Lo SKU dell’articolo
- La quantità ordinata
Se il nome del cliente non esiste oppure l’articolo non esiste, il servizio restituirà un codice errore altrimenti restituirà il riferimento al numero ordine che è stato creato.
- Accedi alla schermata del modulo e clicca Create Template
- Specifica il nome del Template (es. createorder) e clicca Create Template
- Clicca Create Handler e seleziona il metodo POST
- Inserisci nel Body dell’Handler il seguente script PL-SQL.
declare
l_customer_id number;
l_product_id number;
l_order_number number;
l_status_code varchar2(250);
l_status_message varchar2(400);
begin
begin
select id into l_customer_id from CUSTOMERS where id = :customer;
exception
when others then
l_order_number := '-1';
l_status_code := 'KO';
l_status_message := 'Customer NOT exists';
end;
begin
select id into l_product_id from PRODUCTS where id = :product;
exception
when others then
l_order_number := '-1';
l_status_code := 'KO';
l_status_message := 'Product NOT exists';
end;
if nvl(l_status_code,'OK') not in ('KO') then
insert into ORDERS (CUSTOMER, PRODUCT, QUANTITY) values (1, 1, 1)
returning id into l_order_number;
commit;
l_status_code := 'OK';
l_status_message := 'Order Created';
end if;
:order_number := l_order_number;
:status_code := l_status_code;
:status_message := l_status_message;
exception when others then
:order_number := '-1';
:status_code := 'KO';
:status_message := 'Errore Generico';
end;
- Vai alla sezione Parameters ed aggiungi i seguenti parametri
- customer: identificativo del cliente da passare in input nell’header della richiesta
- product: identificativo del prodotto da passare in input nell’header della richiesta
- quantity: quantità ordinata da passare in input nell’header della richiesta
- order-number: numero ordine restituito nel corpo risposta
- status-code: esito dell’operazione restituito nell’header risposta
- status-message: messaggio restituito dalla procedura nell’header risposta
Proviamo ad eseguire questo web service usando Postman.
- Accedi a Postman e crea una nuova Request di tipo POST
- Inserisci l’end-point del servizio
- Vai in Header ed inserisci i parametri e poi premi Send.
Se hai inserito i parametri corretti (cliente e prodotto validi) allora dovrebbe essere inserito un record nella tabella ORDERS e nel Body della Response dovrebbe essere restituito il numero ordine.
Nell’header della response dovresti vedere i parametri status-code e status-message
Se lo desideri puoi spostarli nel body della response.
Questo sarà il risultato
Se, invece, inserisci parametri non validi (ad esempio un articolo che non esiste) otterrai questo risultato
Come configurare un Metodo PUT
Il metodo PUT viene utilizzato quando devi modificare una risorsa come, ad esempio, un record di database.
Creiamo un servizio PUT in grado di aggiornare la quantità di un ordine di vendita.
- Accedi alla schermata del modulo e clicca Create Template
- Specifica il nome del Template (es. updateorder) e clicca Create Template
- Clicca Create Handler e seleziona il metodo PUT
- Inserisci nel Body dell’Handler il seguente script PL-SQL
declare
l_order_id number;
l_status_code varchar2(250);
l_status_message varchar2(4000);
begin
begin
select id into l_order_id from ORDERS where ID = :order_number;
exception when others then
l_order_id := -1;
l_status_code := 'KO';
l_status_message := 'Ordine NON Valido';
end;
if l_order_id > 0 then
update ORDERS
set quantity = :quantity
where id = :order_number;
commit;
l_status_code := 'OK';
l_status_message := 'Qty Aggiornata';
end if;
:status_code := l_status_code;
:status_message := l_status_message;
end;- Vai alla sezione Parameters ed aggiungi i seguenti parametri
- quantity: quantità ordinata da passare in input nell’header della richiesta
- order-number: numero ordine restituito nel corpo risposta
- status-code: esito dell’operazione restituito nell’header risposta
- status-message: messaggio restituito dalla procedura nell’header risposta
Come configurare un Metodo DELETE
Il metodo DELETE viene utilizzato quando devi eliminare una risorsa come, ad esempio, un record di database.
Arrivati a questo punto, immagino tu abbia capito come fare.
- Accedi alla schermata del modulo e clicca Create Template
- Specifica il nome del Template (es. deleteorder) e clicca Create Template
- Clicca Create Handler e seleziona il metodo DELETE
- Inserisci nel Body dell’Handler il seguente script PL-SQL
declare
l_order_id number;
l_status_code varchar2(250);
l_status_message varchar2(4000);
begin
begin
select id into l_order_id from ORDERS where ID = :order_number;
exception when others then
l_order_id := -1;
l_status_code := 'KO';
l_status_message := 'Ordine NON Valido';
end;
if l_order_id > 0 then
delete from ORDERS
where id = :order_number;
commit;
l_status_code := 'OK';
l_status_message := 'Ordine Eliminato';
end if;
:status_code := l_status_code;
:status_message := l_status_message;
end;- Vai alla sezione Parameters ed aggiungi i seguenti parametri
- order-number: numero ordine restituito nel corpo risposta
- status-code: esito dell’operazione restituito nell’header risposta
- status-message: messaggio restituito dalla procedura nell’header risposta
Come configurare un Metodo GET con Response JSON Personalizzato
Nell’esempi precedenti i vari servizi RESTful che abbiamo creato sono stati in grado di generare delle Response JSON in modo automatico direttamente da ORDS.
Tuttavia, questo potrebbe essere un limite perché potremmo aver bisogno di generare come Response documenti JSON più complessi.
Fortunatamente questo non è un problema perché possiamo creare una Response personalizzata usando un Handler di tipo PL-SQL.
- Accedi alla schermata del modulo e clicca Create Template
- Specifica il nome del Template (es. listorders) e clicca Create Template
- Clicca Create Handler e seleziona il metodo GET con Source Type PL/SQL.
- Inserisci nel Body dell’Handler il seguente script PL-SQL
DECLARE
items_cursor SYS_REFCURSOR;
l_item_exist number;
l_ret_message varchar2(250);
BEGIN
select count(1) into l_item_exist from ORDERS where customer = :customer;
if (l_item_exist > 0) then
l_ret_message := 'Success';
else
l_ret_message := 'No Orders Found';
end if;
OPEN items_cursor FOR
SELECT *
FROM (select orders.id order_number,
products.sku product_code,
products.description product_description,
products.unit_price,
(quantity * unit_price) selling_price
from orders, products
where orders.product = products.id
and customer = :customer) tmp;
APEX_JSON.open_object;
APEX_JSON.write ('ordini', items_cursor);
APEX_JSON.write ('message', l_ret_message);
APEX_JSON.close_object;
END;
Come puoi notare utilizzando il package APEX_JSON possiamo personalizzare la Response come meglio crediamo.
Per maggiori dettagli su come manipolare i documento JSON puoi fare riferimento alla JSON Developer’s Guide.
Come configurare un Metodo GET con Response XML
Oltre che il formato JSON, potrebbe essere necessario generare delle Response in altri formati, ad esempio XML.
Ecco un esempio di Handler PL-SQL che puoi usare per generare una Response XML.
begin
--set the response format
owa_util.mime_header('application/xml', true, 'ISO-8859-4');
htp.p('<?xml version="1.0" encoding="UTF-8" ?>');
htp.p('<ROOT>');
htp.p('<NAME>JOHN</NAME>');
htp.p('<SURNAME>SMITH</SURNAME>');
htp.p('<CONTENT_TYPE>Here is the content..</CONTENT_TYPE>');
htp.p('</ROOT>');
end;Questo è il risultato
Come configurare un Metodo GET con Response HTML
Ecco un esempio di Handler PL-SQL che puoi usare per generare una Response HTML.
DECLARE
prevdeptno NUMBER;
total_rows NUMBER;
l_customer_name VARCHAR2(250);
CURSOR getorders IS
SELECT *
FROM (SELECT orders.id order_number,
products.sku product_code,
products.description product_description,
products.unit_price,
quantity,
( quantity * unit_price ) selling_price
FROM orders,
products
WHERE orders.product = products.id
AND customer = :customer) tmp;
BEGIN
BEGIN
SELECT name
INTO l_customer_name
FROM customers
WHERE id = :customer;
EXCEPTION
WHEN OTHERS THEN
l_customer_name := NULL;
END;
IF ( l_customer_name IS NOT NULL ) THEN
sys.htp.htmlopen;
sys.htp.headopen;
sys.htp.Title('Orders for Customer '
||l_customer_name);
sys.htp.headclose;
sys.htp.bodyopen;
sys.htp.Print('<h2>Orders for Customer '
||l_customer_name
||'</h2>');
sys.htp.Print('<table>');
sys.htp.Print('<tr>');
sys.htp.Print('<th>Order Number</th>');
sys.htp.Print('<th>Product</th>');
sys.htp.Print('<th>Description</th>');
sys.htp.Print('<th>Quantity</th>');
sys.htp.Print('<th>Sellign Price</th>');
sys.htp.Print('</tr>');
FOR orderrecs IN getorders LOOP
sys.htp.Print('<tr>');
sys.htp.Print('<td>' ||orderrecs.order_number ||'</td>');
sys.htp.Print('<td>' ||orderrecs.product_code ||'</td>');
sys.htp.Print('<td>' ||orderrecs.product_description ||'</td>');
sys.htp.Print('<td>' ||orderrecs.quantity ||'</td>');
sys.htp.Print('<td>' ||orderrecs.selling_price ||'</td>');
sys.htp.Print('</tr>');
END LOOP;
sys.htp.Print('</table>');
sys.htp.bodyclose;
sys.htp.htmlclose;
ELSE
sys.htp.htmlopen;
sys.htp.headopen;
sys.htp.Title('No Customer Found');
sys.htp.headclose;
sys.htp.bodyopen;
sys.htp.Print('<h2>No Customer Found</h2>');
sys.htp.bodyclose;
sys.htp.htmlclose;
END IF;
END; Come gestire gli accessi autorizzati alle API RESTful
Bene, abbiamo creato i nostri servizi e li abbiamo pubblicati.
A questo punto di dobbiamo porre una domanda: devono essere servizi protetti da un meccanismo di autenticazione?
Ovvero, vogliamo che chiunque li possa utilizzare o dobbiamo garantire un certo livello di sicurezza?
Trattandosi di servizi esposti verso l’esterno è un problema non da poco.
Fortunatamente non dobbiamo scervellarci troppo perché Oracle mette a disposizione diversi meccanismi per gestire l’accesso autorizzato ai servizi esposti via ORDS, come, ad esempio il protocollo OAuth 2.0.
Leggi Come configurare OAuth 2.0 per un servizio REST in Oracle APEX
Conclusioni
Siamo arrivati alla fine di questo tutorial che spero che tu abbia trovato utile.
Fammi sapere cosa ne pensi!
Un abbraccio
Daniele
Lascia un commento