Come progettare software estensibile (architettura plug-in)? [chiuso]

StackOverflow https://stackoverflow.com/questions/323202

Domanda

Ho bisogno di alcune risorse che parlino di come progettare il tuo software in modo che sia estensibile, cioè in modo che altre persone possano scrivere componenti aggiuntivi / plug-in che aggiungano funzionalità ad esso.

Cosa mi consigliate? Qualche libro là fuori che parla dell'argomento?
Preferirei qualcosa che sia breve e al punto; un po 'di teoria e un mucchio di esempi concreti.

Non sto prendendo di mira una lingua specifica, voglio essere in grado di comprendere l'idea di base in modo da poterla implementare in qualsiasi lingua.

E per lo stesso motivo, preferisco non farlo usando un framework che qualcun altro ha costruito (a meno che il framework non sia di livello molto alto, cioè non nasconda troppo ), a nel momento in cui voglio solo educare me stesso sull'argomento e sperimentare vari modi per implementarlo. Inoltre, un framework di solito presuppone la conoscenza dell'utente sull'argomento.

Aggiorna

Non sto chiedendo di OOP o di consentire che le mie classi vengano ereditate. Sto parlando della progettazione di un'applicazione che verrà distribuita su un sistema, in modo che possa essere estesa da componenti aggiuntivi di terze parti DOPO che sia stata distribuita.

Ad esempio, Notepad ++ ha un'architettura plug-in in cui è possibile inserire un file .dll nella cartella dei plug-in e aggiunge funzionalità all'applicazione che non c'era, come la selezione dei colori o l'inserimento di frammenti, oppure molte altre cose (una vasta gamma di funzionalità).

Altri suggerimenti

OSGI è un buon esempio pratico di un quadro tecnico che consente di fare ciò che cerchi.

La è qui .

Il (gratuito!) è lì .

L'estensibilità e la capacità di scrivere plugin devono gestire il ciclo di vita del servizio

  • aggiunta / rimozione di servizio / plugin sul posto
  • gestione delle dipendenze tra servizi
  • gestione degli stati dei servizi (dichiarati, installati, avviati, arrestati, ...)

A cosa serve l'OSGI?

  

Una delle funzioni principali di un modulo è come unità di distribuzione ... qualcosa che possiamo costruire o scaricare e installare per estendere la funzionalità della nostra applicazione.

Troverai una una buona introduzione qui , sulla nozione centrale di service (che è correlato alla tua domanda e che spiega alcuni problemi relativi ai servizi, componente chiave per l'estensibilità).

Estratto:

  

Perché i servizi sono così importanti se così tante applicazioni possono essere costruite senza di loro? Bene, i servizi sono il modo più noto per separare i componenti software l'uno dall'altro.

     

Uno degli aspetti più importanti dei servizi è che minimizzano significativamente i problemi di caricamento delle classi perché lavorano con istanze di oggetti, non con nomi di classe. Istanze create dal fornitore, non dal consumatore. La riduzione della complessità è piuttosto sorprendente

     

I servizi non solo riducono al minimo la configurazione, ma riducono anche in modo significativo il numero di pacchetti condivisi.

Cerchi di raggiungere due obiettivi in ??competizione:

  1. I componenti del tuo software devono esporre molto da soli, quindi possono essere riutilizzati
  2. I componenti del tuo software devono esporre molto poco di se stessi, quindi possono essere riutilizzati

Spiegazione: per incoraggiare il riutilizzo del codice, dovresti essere in grado di estendere le classi esistenti e chiamarne i metodi. Questo non è possibile quando i metodi sono dichiarati "privati". e le classi sono "finali" (e non può essere esteso). Quindi, per raggiungere questo obiettivo, tutto dovrebbe essere pubblico e accessibile. Nessun dato o metodo privato.

Quando rilasci la seconda versione del tuo software, scoprirai che molte delle idee della versione 1 erano chiaramente sbagliate. È necessario modificare molte interfacce o il codice, i nomi dei metodi, eliminare i metodi, interrompere l'API. Se lo fai, molte persone si allontaneranno. Quindi, al fine di poter evolvere il tuo software, i componenti non devono esporre tutto ciò che non è assolutamente necessario - a costo di riutilizzo del codice.

Esempio: volevo osservare la posizione del cursore (cursore) in un SWT StyledText. Il cursore non è pensato per essere esteso. Se lo fai, scoprirai che il codice contiene controlli come " è questa classe nel pacchetto org.eclipse.swt " e molti metodi sono privati ??e finali e quant'altro. Ho dovuto copiare circa 28 classi da SWT nel mio progetto solo per implementare questa funzione perché tutto è bloccato.

SWT è un bel framework da usare e l'inferno da estendere.

Implementa SOLID nella tua applicazione.

1. Principio di responsabilità unica: una classe dovrebbe avere una sola responsabilità (vale a dire che solo un potenziale cambiamento nelle specifiche del software dovrebbe essere in grado di influenzare le specifiche della classe

2. Principio aperto / chiuso: le entità software ... dovrebbero essere aperte per l'estensione, ma chiuse per modifiche

3. Principio di sostituzione di Liskov: gli oggetti in un programma dovrebbero essere sostituibili con istanze dei loro sottotipi senza alterare la correttezza di quel programma

4. Principio di segregazione dell'interfaccia: molte interfacce specifiche per client sono migliori di un'interfaccia per tutti gli usi

5. Principio di inversione di dipendenza: Uno dovrebbe dipendere dalle astrazioni . Non dipendere da concrezioni

Domande su StackOverflow:

Esempio di principio di responsabilità singola

Il principio Open / Closed è una buona idea?

Che cos'è il principio di sostituzione di Liskov?

Principio di segregazione dell'interfaccia- Programma su un'interfaccia

Che cos'è il principio di inversione di dipendenza e perché è importante?

Naturalmente c'è il famoso principio chiuso aperto - http://en.wikipedia.org / wiki / Open / closed_principle

Beh, dipende dalla lingua.

  • In C / C ++ sono abbastanza sicuro che esiste una funzione loadlibrary che ti consente di aprire una libreria in fase di esecuzione e invocarne le funzioni esportate. In genere è così che si fa in C / C ++.
  • In .NET, c'è Reflection, che offre un simile (ma più ampio) al loadlibrary. Esistono anche intere librerie costruite su Reflection come Managed Extension Framework o Mono.Addins che già svolgono gran parte del lavoro pesante per te.
  • In Java, c'è anche Reflection. E c'è il JPF (Java Plugin Framework) che viene usato in cose come Eclipse IIRC.

A seconda della lingua che uso potrei consigliare alcuni tutorial / libri. Spero sia stato utile.

L'articolo Scrivere applicazioni basate su plug-in spiega chiaramente responsabilità delle varie parti dell'architettura usando un esempio molto semplice; viene fornito il codice sorgente (VB.Net). L'ho trovato molto utile per comprendere i concetti di base.

Acquista " CAB " - Microsoft Composizione Application Blocks Framework . Penso che abbiano una versione web " anche di quello ...

Ho appena iniziato a sviluppare un'applicazione smart client. Sono due opzioni che sto prendendo in considerazione.

Uso dello spazio dei nomi di Microsoft System.AddIn . Sembra molto promettente, tuttavia potrebbe essere un po 'complesso per la nostra soluzione finale.

O lo Smart Client - Blocco applicazione UI composita da Microsoft

Di recente, ho preso in considerazione l'idea di creare i miei componenti sia il Blocco applicazione dell'interfaccia utente composita sia lo spazio dei nomi System.AddIn. Poiché il codice sorgente è disponibile per il CAB, è facile da estendere. Penso che la nostra soluzione finale sarà una versione leggera del CAB, usando sicuramente il Unity Application Block

L'architettura dei plug-in sta diventando molto popolare per la sua estensibilità e quindi flessibilità.

Per c ++, il server httpd di Apache è in realtà basato su plugin, ma al suo posto viene utilizzato un concetto di modulo. La maggior parte delle funzionalità di Apache sono implementate come moduli, come cache, riscrittura, bilanciamento del carico e persino modello di threading. È un software molto modulare che abbia mai visto.

E per Java, Eclipse è sicuramente basato su plugin. Il cuore di Eclipse è un sistema di moduli OSGI che gestisce bundle, un altro concetto di plugin. Il bundle può fornire punti di estensione su cui possiamo costruire moduli con meno sforzi. La cosa più complessa in OSGI è la sua caratteristica dinamica, il che significa che i pacchetti possono essere installati o disinstallati in fase di esecuzione. Niente più sindrome del mondo!

Se lavori con .Net, la nostra ricerca ha prodotto due approcci: scripting e composizione.

Scripting

Estendi la funzionalità di ciò che le tue classi possono fare orchestrandole tramite script. Ciò significa esporre ciò che è compilato nella tua lingua .Net preferita in una lingua dinamica.

Alcune opzioni che abbiamo trovato degno di essere esplorato:

Composizione

Se si avvia un progetto con .Net 4 o versione successiva, è necessario dare un'occhiata al Managed Extensibility Framework (MEF). Ti consente di estendere la funzionalità delle tue app in modo plug-in.

  

Managed Extensibility Framework (MEF) è un livello di composizione per   .NET che migliora la flessibilità, la manutenibilità e la testabilità di   grandi applicazioni. MEF può essere utilizzato per plugin di terze parti   estensibilità, o può portare i vantaggi di un accoppiamento debole   architettura simile a un plugin per applicazioni normali.

Managed Add-in Framework è anche una buona lettura.

Dato che non ho abbastanza punti rappresentante per lasciare un commento, sto pubblicando questo come risposta. SharpDevelop è un IDE per lo sviluppo di applicazioni in C # / VB.NET / Boo. Ha un'architettura piuttosto impressionante che si consente di essere estesa in diversi modi: dalle nuove voci di menu al supporto allo sviluppo di lingue completamente nuove.

Utilizza un po 'di configurazione XML per fungere da strato di colla tra un nucleo dell'IDE e l'implementazione del plugin. Gestisce localizzazione, caricamento e versioning dei plug-in pronti all'uso. L'implementazione di nuovi plug-in richiede semplicemente la copia nel nuovo file di configurazione xml e negli assembly richiesti (DLL) e il riavvio dell'applicazione. Puoi leggere di più su questo nel libro "Analisi di un'applicazione csharp" dell'autore o degli autori originali - Christian Holm, Mike Kr & # 252; ger, Bernhard Spuida dell'applicazione da qui . Il libro non sembra essere disponibile su quel sito, ma ho trovato una copia che potrebbe essere ancora in giro qui

Ho anche trovato una domanda correlata qui

Invece di reinventare la ruota, usa le strutture in mano. Eclipse e Netbeans supportano entrambe le estensioni basate su plug-in. Devi lavorare in Java però.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top