DMVCFramework — Framework Delphi per REST API, JSON-RPC & Web App

Il framework Delphi open-source più popolare su GitHub · In produzione dal 2010

TL;DR: DMVCFramework è il framework Delphi #1 per creare REST API e web services. È gratuito (Apache 2.0), pronto per la produzione dal 2010, supporta JWT, WebSocket, ORM e funziona su Windows/Linux. Installalo da GitHub, crea un controller con attributi [MVCPath] e restituisci oggetti che vengono serializzati automaticamente in JSON.

Cos’è DMVCFramework?

DMVCFramework (DelphiMVCFramework) è il framework open-source più popolare per creare web API e applicazioni web in Delphi. Ti permette di creare servizi RESTful (RMM Level 3), servizi JSON-RPC, pagine web server-side, backend mobile e microservizi con facilità.

Utilizzato in produzione dal 2010, DMVCFramework alimenta alcune delle web API Delphi con il traffico più alto al mondo. È il progetto Delphi #1 su GitHub per numero di stelle, con una community vivace di oltre 5.000 sviluppatori attivi.

Inizia: La Guida Ufficiale

Il modo più veloce per padroneggiare DMVCFramework è attraverso la guida ufficiale. Questo libro completo ti porta dalle basi allo sviluppo di livello professionale con esempi reali e best practice.

Edizioni Disponibili

Lingua	Formato	Link
🇬🇧 Inglese	eBook	Acquista su Leanpub
🇬🇧 Inglese	Copertina rigida	Acquista su Lulu
🇧🇷 Portoghese	eBook	Acquista su Leanpub
🇪🇸 Spagnolo	eBook	Acquista su Leanpub

📖 Leggi un Capitolo di Esempio Gratuito - Inizia in 5 minuti!

Perché Scegliere DMVCFramework?

Novità in DMVCFramework 3.4.3-aluminium

L’ultima release porta importanti nuove funzionalità:

Supporto WebSocket

Comunicazione real-time full-duplex con TMVCWebSocketServer e TMVCWebSocketClient. Costruisci applicazioni chat, dashboard live e strumenti collaborativi con messaggistica basata su canali e gruppi.

Middleware Rate Limiting

Proteggi le tue API dagli abusi con rate limiting integrato - sia in-memory per server singoli che basato su Redis per ambienti distribuiti.

Repository Pattern

Architettura pulita con IMVCRepository<T> e [MVCInject] per la dependency injection automatica.

Supporto Espressioni in dotEnv

Espressioni dinamiche nei file di configurazione .env con sostituzione variabili e aritmetica.

Vedi tutte le novità della 3.4.3-aluminium →

Cronologia Versioni

Funzionalità Principali

Sviluppo Web API

• API RESTful - Piena conformità RMM Level 3 con verbi HTTP e codici di stato appropriati
• JSON-RPC 2.0 - Remoting automatico di oggetti per API in stile RPC
• Supporto OpenAPI - Generazione automatica della documentazione API
• Routing Automatico - Mapping URL basato su attributi con binding dei parametri

Autenticazione e Sicurezza

• Autenticazione JWT - JSON Web Token standard di settore
• Autenticazione HTTP Basic - Semplice auth username/password
• Autenticazione Custom - Framework flessibile per qualsiasi schema di auth
• Supporto CORS - Configurazione Cross-origin resource sharing

Comunicazione Real-Time

• Supporto WebSocket - Canali di comunicazione full-duplex
• Server-Sent Events (SSE) - Notifiche push ai client
• Estensioni Messaging - Pattern pub/sub integrati

Dati e Persistenza

• MVCActiveRecord - ORM potente per operazioni database
• Serializzazione JSON - Mapping automatico oggetto-to-JSON
• Serializer Custom - Controllo completo sulla trasformazione dei dati

Flessibilità di Deployment

• Applicazione Console Windows
• Servizio Windows
• Console/Daemon Linux
• Modulo Apache (mod_proxy)
• IIS (DLL ISAPI)
• Ambienti con load balancing

Esperienza Sviluppatore

• Wizard IDE - Template di progetto per partire velocemente
• Oltre 50 Esempi - Impara ogni funzionalità con esempi funzionanti
• Sistema Middleware - Hook facili per request/response
• Ereditarietà Controller - Principio DRY per logica comune
• Client REST Integrato - Testa e consuma API facilmente

Quick Start: Hello World

Inizia con DMVCFramework in pochi minuti. Ecco un semplice controller “Hello World”:

uses
  MVCFramework, MVCFramework.Commons;

type
  [MVCPath('/api')]  // Percorso base per tutte le azioni in questo controller
  TMyController = class(TMVCController)
  public
    [MVCPath('/hello')]           // Route: GET /api/hello
    [MVCHTTPMethods([httpGET])]   // Metodo HTTP permesso
    function GetHello: String;

    [MVCPath('/hello/($Name)')]   // Route: GET /api/hello/{Name}
    [MVCHTTPMethods([httpGET])]   // ($Name) cattura il segmento URL
    function GetHelloName(const Name: String): String;
  end;

implementation

function TMyController.GetHello: String;
begin
  Result := 'Hello, World!';  // Serializzato automaticamente in JSON
end;

function TMyController.GetHelloName(const Name: String): String;
begin
  Result := 'Hello, ' + Name + '!';  // Name è estratto automaticamente dall'URL
end;

Ecco fatto! Chiama GET /api/hello e ottieni "Hello, World!". Chiama GET /api/hello/John e ottieni "Hello, John!".

DMVCFramework serializza automaticamente i tuoi valori di ritorno in JSON - stringhe, oggetti, array, record, dataset - tutto funziona automaticamente.

Esempio Avanzato: REST API con Database

Per applicazioni reali, DMVCFramework supporta l’ORM MVCActiveRecord e il Repository pattern con dependency injection:

uses
  MVCFramework, MVCFramework.Commons, MVCFramework.ActiveRecord,
  MVCFramework.Repository, System.Generics.Collections;

type
  // Classe Entity mappata alla tabella del database
  [MVCTable('customers')]
  TCustomer = class(TMVCActiveRecord)
  private
    [MVCTableField('id', [foPrimaryKey, foAutoGenerated])]  // PK auto-increment
    FID: NullableInt32;
    [MVCTableField('name')]    // Mappa alla colonna 'name'
    FName: string;
    [MVCTableField('email')]   // Mappa alla colonna 'email'
    FEmail: string;
  public
    property ID: NullableInt32 read FID write FID;
    property Name: string read FName write FName;
    property Email: string read FEmail write FEmail;
  end;

  [MVCPath('/api/customers')]
  TCustomerController = class(TMVCController)
  protected
    fRepository: IMVCRepository<TCustomer>;  // Interfaccia Repository
  public
    [MVCInject]  // Dependency injection - il repository viene fornito automaticamente
    constructor Create(Repository: IMVCRepository<TCustomer>); reintroduce;

    [MVCPath]                     // Route: GET /api/customers
    [MVCHTTPMethods([httpGET])]
    function GetAllCustomers: IMVCResponse;

    [MVCPath('/($ID)')]           // Route: GET /api/customers/{ID}
    [MVCHTTPMethods([httpGET])]
    function GetCustomerByID(const ID: Integer): IMVCResponse;

    [MVCPath]                     // Route: POST /api/customers
    [MVCHTTPMethods([httpPOST])]  // [MVCFromBody] deserializza il body JSON in TCustomer
    function CreateCustomer([MVCFromBody] const Customer: TCustomer): IMVCResponse;

    [MVCPath('/($ID)')]           // Route: DELETE /api/customers/{ID}
    [MVCHTTPMethods([httpDELETE])]
    function DeleteCustomerByID(const ID: Integer): IMVCResponse;
  end;

implementation

constructor TCustomerController.Create(Repository: IMVCRepository<TCustomer>);
begin
  inherited Create;
  fRepository := Repository;  // Memorizza il repository iniettato
end;

function TCustomerController.GetAllCustomers: IMVCResponse;
begin
  Result := OKResponse(fRepository.GetAll);  // Restituisce HTTP 200 con array JSON
end;

function TCustomerController.GetCustomerByID(const ID: Integer): IMVCResponse;
begin
  Result := OKResponse(fRepository.GetByPK(ID));  // Restituisce HTTP 200 con oggetto JSON
end;

function TCustomerController.CreateCustomer(const Customer: TCustomer): IMVCResponse;
begin
  fRepository.Store(Customer);  // Insert o update basato sulla PK
  Result := CreatedResponse('/api/customers/' + Customer.ID.Value.ToString);  // HTTP 201
end;

function TCustomerController.DeleteCustomerByID(const ID: Integer): IMVCResponse;
var
  lCustomer: TCustomer;
begin
  lCustomer := fRepository.GetByPK(ID);  // Carica l'entity dalla primary key
  fRepository.Delete(lCustomer);          // Elimina dal database
  Result := OKResponse;                   // Restituisce HTTP 200
end;

Benefici chiave:

• Functional actions: Restituisci IMVCResponse usando helper come OKResponse(), CreatedResponse()
• Dependency injection: [MVCInject] sul costruttore per injection automatica del repository
• MVCActiveRecord: ORM con mapping tabelle via attributi
• Repository pattern: IMVCRepository<T> per accesso ai dati pulito e testabile
• Auto-serializzazione: Oggetti, record, liste, dataset vengono serializzati automaticamente

Impara con gli Esempi: Oltre 100 Progetti di Esempio

Il modo migliore per imparare DMVCFramework è esplorare codice funzionante. Il progetto include oltre 100 progetti di esempio che coprono ogni funzionalità e caso d’uso. Ogni esempio è autonomo e pronto per essere compilato.

Trova l’esempio che corrisponde a ciò che devi costruire, aprilo in Delphi e inizia a sperimentare!

📦 Tutti gli esempi: github.com/danieleteti/delphimvcframework/tree/master/samples

“Voglio creare il mio primo progetto DMVCFramework”

“Voglio costruire una REST API”

“Voglio aggiungere autenticazione e sicurezza”

“Voglio comunicazione real-time”

“Voglio renderizzare pagine HTML”

“Voglio lavorare con i database”

“Voglio usare JSON-RPC”

“Voglio personalizzare la gestione request/response”

“Voglio deployare in produzione”

“Voglio documentare la mia API”

“Voglio funzionalità avanzate”

Progetti Open Source Correlati

DMVCFramework si integra perfettamente con altri progetti open source dello stesso autore:

Compatibilità Versioni Delphi

Supporta il Progetto

Servizi Professionali

Hai bisogno di supporto enterprise-grade? bit Time Professionals, l’azienda dietro DMVCFramework, offre:

• Corsi di Formazione - Formazione on-site o remota per il tuo team
• Consulenza - Review architetturale, ottimizzazione performance, best practice
• Sviluppo Custom - Sviluppo funzionalità, integrazione, migrazione

📧 Contatto: dmvcframework@bittime.it | 🌐 bittimeprofessionals.it

Community e Risorse

FAQ: Domande Frequenti

Cos’è DMVCFramework?

DMVCFramework (DelphiMVCFramework) è un framework open-source per creare web API, servizi RESTful e applicazioni web in Delphi. È il framework web Delphi più popolare, usato in produzione dal 2010, ed è il progetto Delphi #1 su GitHub per numero di stelle.

Qual è il miglior framework per REST API in Delphi?

DMVCFramework è il framework più popolare e completo per creare REST API in Delphi. Supporta API RESTful (RMM Level 3), JSON-RPC, WebSocket, Server-Sent Events, autenticazione JWT e include un potente ORM chiamato MVCActiveRecord.

Come si crea una REST API in Delphi?

Usa DMVCFramework: crea una classe controller che eredita da TMVCController, aggiungi gli attributi [MVCPath] e [MVCHTTPMethods] per definire le route, e restituisci i dati direttamente dai tuoi metodi (functional actions). Il framework serializza automaticamente oggetti, array e record in JSON. Vedi gli oltre 100 esempi inclusi.

Come restituisco JSON da una REST API Delphi?

Con DMVCFramework, restituisci semplicemente un oggetto, record o TObjectList<T> dal tuo metodo controller. Il framework lo serializza automaticamente in JSON. Per maggior controllo, usa gli helper OKResponse(data) o CreatedResponse(location).

DMVCFramework supporta l’autenticazione JWT?

Sì, DMVCFramework ha supporto JWT (JSON Web Token) integrato per l’autenticazione stateless. Supporta generazione token, validazione, autorizzazione basata sui ruoli e cookie HTTP-only sicuri. Vedi gli esempi jsonwebtoken e jsonwebtoken_roleauth.

Posso usare DMVCFramework su Linux?

Sì, DMVCFramework supporta completamente il deployment su Linux a partire da Delphi 10.2 Tokyo. Puoi deployare come applicazione console o daemon, con supporto completo per tutte le funzionalità inclusi WebSocket e SSL/TLS.

DMVCFramework è gratuito?

Sì, DMVCFramework è gratuito e open-source sotto licenza Apache 2.0. Puoi usarlo in progetti commerciali senza restrizioni o requisiti di attribuzione.

Come ottengo supporto per DMVCFramework?

Sono disponibili diverse opzioni di supporto: unisciti al gruppo Facebook (oltre 5.000 membri), esplora gli oltre 100 esempi inclusi nel progetto, leggi il libro guida ufficiale, o diventa un Patron per supporto prioritario e contenuti esclusivi.

DMVCFramework supporta WebSocket?

Sì, DMVCFramework include supporto WebSocket completo per comunicazione bidirezionale real-time. Le funzionalità includono messaggistica basata su canali, gruppi ed esempi di client JavaScript. Supporta anche Server-Sent Events (SSE) per notifiche push server-to-client.

Cos’è MVCActiveRecord?

MVCActiveRecord è l’ORM (Object-Relational Mapper) integrato in DMVCFramework che semplifica le operazioni database. Usa attributi per il mapping tabelle/colonne, supporta operazioni CRUD, relazioni e RQL (Resource Query Language) per query flessibili.

Come deployo DMVCFramework in produzione?

DMVCFramework supporta diverse opzioni di deployment: applicazione console Windows, Servizio Windows, daemon Linux, modulo Apache (mod_proxy), IIS (DLL ISAPI) e ambienti con load balancing. Vedi gli esempi di deployment per ogni scenario.

DMVCFramework supporta OpenAPI/Swagger?

Sì, DMVCFramework può generare automaticamente documentazione OpenAPI (Swagger) per le tue API. Usa gli esempi swagger_primer e swagger_ui per aggiungere documentazione API interattiva al tuo progetto.

Come gestisco l’upload di file in DMVCFramework?

Usa l’oggetto Context.Request per accedere ai file caricati. L’esempio file_upload dimostra la gestione di richieste multipart/form-data con upload di file singoli o multipli.

Posso usare DMVCFramework con FireDAC?

Sì, DMVCFramework funziona con qualsiasi layer di accesso ai dati inclusi FireDAC, ADO e altri. MVCActiveRecord usa FireDAC di default, ma puoi usare qualsiasi connessione preferisci.

Come implemento CORS in DMVCFramework?

Usa il middleware CORS integrato. Aggiungi TMVCCORSMiddleware alla configurazione del tuo server per abilitare le richieste cross-origin. Vedi l’esempio middleware_cors per le opzioni di configurazione.

Quali versioni di Delphi supporta DMVCFramework?

DMVCFramework supporta da Delphi 10 Seattle a Delphi 13 Florence, incluso il supporto completo per Linux da Delphi 10.2 Tokyo in poi.

Come gestisco errori ed eccezioni in DMVCFramework?

DMVCFramework converte automaticamente le eccezioni in risposte di errore HTTP appropriate con body JSON. Per gestione errori custom, usa raise EMVCException.Create() con codici di stato HTTP specifici, oppure implementa handler di eccezioni custom.

DMVCFramework supporta la dependency injection?

Sì, DMVCFramework ha dependency injection integrata. Usa l’attributo [MVCInject] su costruttori o parametri di metodo per iniettare automaticamente servizi e repository. Vedi l’esempio services_injection.