Cos'è la programmazione orientata all'aspetto?

Question

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 del tutto:

Programmazione orientata agli aspetti vs. Programmazione orientata agli oggetti

Answer 1

AOP affronta il problema di preoccupazioni trasversali , che sarebbe qualsiasi tipo di codice che si ripete in diversi metodi e che normalmente non può essere completamente rifattorizzato nel proprio modulo, come con la registrazione o 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 poi un aspetto-tessitore è usato 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;
} 

Answer 2

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.)

Metto le mie speranze in 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.

Answer 3

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 dell'accesso di sicurezza, esiste un aggancio del linguaggio "fuori banda". di codice normale che può sistematicamente iniettare sicurezza o accedere a routine che non li hanno in modo nativo 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 in questo modo.

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

Answer 4

Copiato da Spring in Action

  

L'AOP è spesso definita come una tecnica che promuove la separazione di   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 la loro funzionalità principale. Servizi di sistema come registrazione,   gestione delle transazioni e sicurezza spesso si fanno strada   componenti le cui responsabilità principali sono qualcos'altro. Questi sistemi   i servizi sono comunemente indicati come preoccupazioni trasversali perché   tendono a tagliare più componenti in un sistema.

Answer 5

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 una "configurazione" attributo (decorazione).

Answer 6

C'è un esempio di AOP, che 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 le preoccupazioni trasversali negli 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-consiglio /

Answer 7

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 al metodo ed esegui il codice prima delle chiamate al metodo after saif.

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

Answer 8

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ù alti di manutenibilità ed estensibilità nell'applicazione nel tempo.