Cos'è la programmazione orientata all'aspetto?

Comprendo la programmazione orientata agli oggetti e scrivo programmi OO da molto tempo. Le persone sembrano parlare di programmazione orientata all'aspetto, ma non ho mai davvero imparato di cosa si tratta o come usarlo. Qual è il paradigma di base?

Questa domanda è correlata, ma non la pone proprio:

Programmazione orientata agli aspetti vs. programmazione orientata agli oggetti

AOP affronta il problema delle preoccupazioni trasversali , che sarebbe qualsiasi tipo di codice che si ripete in diversi metodi e che normalmente non può essere completamente refactorizzato nel proprio modulo, come con la registrazione o la verifica. Quindi, con AOP puoi lasciare quella roba fuori dal codice principale e definirla verticalmente in questo modo:

function mainProgram()
{ 
   var x =  foo();
   doSomethingWith(x);
   return x;
}

aspect logging
{ 
    before (mainProgram is called):
    { 
       log.Write("entering mainProgram");
    }

    after (mainProgram is called):
    { 
       log.Write(  "exiting mainProgram with return value of "
                  + mainProgram.returnValue);
    }
 } 

aspect verification
{ 
    before (doSomethingWith is called):
    { 
       if (doSomethingWith.arguments[0] == null) 
       { 
          throw NullArgumentException();
       }

       if (!doSomethingWith.caller.isAuthenticated)
       { 
          throw Securityexception();
       }
    }
 }

E quindi un aspetto-tessitore viene utilizzato per compilare il codice in questo:

function mainProgram()
{ 
   log.Write("entering mainProgram");

   var x = foo();   

   if (x == null) throw NullArgumentException();
   if (!mainProgramIsAuthenticated()) throw Securityexception();
   doSomethingWith(x);   

   log.Write("exiting mainProgram with return value of "+ x);
   return x;
} 

Sfortunatamente, sembra sorprendentemente difficile rendere l'AOP davvero utile in una normale organizzazione di dimensioni medio-grandi. (Supporto dell'editor, senso del controllo, il fatto che inizi con le cose non così importanti che portano al marciume del codice, le persone che vanno a casa dalle loro famiglie, ecc.)

Ho sperato in una programmazione orientata al composito , che è qualcosa di sempre più realistico. Si collega a molte idee popolari e ti dà qualcosa di veramente interessante.

Guarda un'implementazione emergente qui: qi4j.org/

PS. In realtà, penso che una delle bellezze con AOP sia anche il suo tallone d'Achille: è non invadente, permettendo alle persone di ignorarlo se possibile, quindi sarà trattato come una preoccupazione secondaria nella maggior parte delle organizzazioni.

Copiato da un duplicato per completezza (Einstein):

Gli esempi classici sono sicurezza e registrazione. Invece di scrivere codice all'interno dell'applicazione per registrare la presenza di x o controllare l'oggetto z per il controllo degli accessi di sicurezza, esiste un aggancio del linguaggio "fuori banda" del codice normale che può iniettare sistematicamente sicurezza o accedere a routine che non li hanno nativamente in modo tale che anche se il tuo codice non lo fornisce - è curato.

Un esempio più concreto è il sistema operativo che fornisce i controlli di accesso a un file. Non è necessario che un programma software controlli le restrizioni di accesso perché il sistema sottostante funziona correttamente.

Se pensi di aver bisogno di AOP nella mia esperienza, in realtà devi davvero investire più tempo e sforzi nella corretta gestione dei metadati all'interno del tuo sistema, con particolare attenzione alla progettazione strutturale / sistematica ben ponderata.

Copiato da Spring in Action

L'AOP è spesso definita come una tecnica che promuove la separazione delle preoccupazioni in un sistema software. I sistemi sono composti da diversi componenti, ciascuno responsabile di una specifica funzionalità. Ma spesso questi componenti comportano anche responsabilità aggiuntive oltre alla loro funzionalità principale. I servizi di sistema come la registrazione, la gestione delle transazioni e la sicurezza spesso trovano la loro strada in componenti le cui responsabilità principali sono qualcos'altro. Questi servizi di sistema sono comunemente indicati come problemi trasversali perché tendono a tagliare più componenti di un sistema.

Copiato da un duplicato per completezza (Buzzer):

Gli attributi di classe e metodo in .NET sono una forma di programmazione orientata all'aspetto. Decorate le vostre classi / metodi con attributi. Dietro le quinte questo aggiunge il codice alla tua classe / metodo che svolge le particolari funzioni dell'attributo. Ad esempio, contrassegnare una classe serializzabile consente di serializzarla automaticamente per la memorizzazione o la trasmissione a un altro sistema. Altri attributi potrebbero contrassegnare alcune proprietà come non serializzabili e queste verrebbero automaticamente omesse dall'oggetto serializzato. La serializzazione è un aspetto, implementato da altro codice nel sistema e applicato alla tua classe dall'applicazione di un attributo "configurazione" (decorazione).

AOP può essere utilizzato per eseguire azioni non correlate alla logica aziendale dell'app come registrazione, memorizzazione nella cache, ecc. Queste azioni possono essere inserite in una parte separata dell'app e quindi riutilizzate in tutta l'applicazione. Di solito ci sono due modi per farlo. Iniettare codice automagicamente da un preprocessore prima / dopo un metodo o associando classi proxy che intercettano una chiamata di metodo e possono quindi eseguire operazioni prima / dopo una chiamata di metodo.

Ecco un esempio in .Net. Utilizza le classi proxy per intercettare le chiamate di metodo ed eseguire il codice prima o dopo le chiamate di metodo saif.

Aspect Oriented Programming (AOP) in .NET Core e C # utilizzando AutoFac e DynamicProxy

C'è un esempio di AOP, ha usato la primavera AOP come esempio. L'esempio è abbastanza facile da capire.

Il framework AOP di primavera (programmazione orientata agli aspetti) viene utilizzato per modulare gli aspetti trasversali degli aspetti. In parole povere, è solo un intercettore per intercettare alcuni processi, ad esempio quando viene eseguito un metodo, Spring AOP può dirottare il metodo di esecuzione e aggiungere funzionalità extra prima o dopo l'esecuzione del metodo.

Riferimento: http://www.mkyong.com/spring/spring-aop-examples-advice/

AOP è un modo per modulare meglio l'applicazione per funzionalità che si estendono su più confini. AOP è un altro modo per incapsulare queste funzionalità e seguire la singola responsabilità spostando queste preoccupazioni trasversali (registrazione, gestione degli errori, ecc.) Dai componenti principali dell'applicazione. Se utilizzato in modo appropriato, AOP può portare a livelli più elevati di manutenibilità ed estensibilità nell'applicazione nel tempo.