Was ist aspektorientierte Programmierung?

Ich verstehe objektorientierte Programmierung und schreibe seit langer Zeit OO-Programme. Die Leute scheinen über aspektorientiertes Programmieren zu sprechen, aber ich habe nie wirklich gelernt, was es ist oder wie man es benutzt. Was ist das grundlegende Paradigma?

Diese Frage ist verwandt, stellt sie aber nicht ganz:

Aspektorientierte Programmierung vs. objektorientierte Programmierung

AOP befasst sich mit dem Problem der Querschnittsthemen. Hierbei handelt es sich um jede Art von Code, der mit verschiedenen Methoden wiederholt wird und normalerweise nicht vollständig in ein eigenes Modul umgewandelt werden kann, z. B. bei der Protokollierung oder Überprüfung. Mit AOP können Sie das Zeug also aus dem Hauptcode herauslassen und es vertikal wie folgt definieren:

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();
       }
    }
 }

Und dann wird ein Aspektweber verwendet, um den Code in diesen zu kompilieren:

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;
} 

Leider scheint es überraschend schwierig zu sein, AOP in einer normalen mittelgroßen Organisation wirklich nützlich zu machen. (Unterstützung der Redakteure, Gefühl der Kontrolle, die Tatsache, dass Sie mit den nicht so wichtigen Dingen beginnen, die zu Code-Rot führen, Menschen, die zu ihren Familien nach Hause gehen usw.)

Ich setze meine Hoffnungen auf eine zusammengesetzte Programmierung , die immer realistischer wird. Es verbindet sich mit vielen beliebten Ideen und gibt Ihnen etwas wirklich Cooles.

Schauen Sie sich hier eine aufstrebende Implementierung an: qi4j.org/

PS. Eigentlich denke ich, dass eine der Schönheiten bei AOP auch die Achillesferse ist: Es ist nicht aufdringlich und lässt die Leute es ignorieren, wenn sie können, so dass es in den meisten Organisationen als zweitrangiges Anliegen behandelt wird.

Der Vollständigkeit halber aus einem Duplikat kopiert (Einstein):

Die klassischen Beispiele sind Sicherheit und Protokollierung. Anstatt Code in Ihre Anwendung zu schreiben, um das Auftreten von x zu protokollieren oder das Objekt z auf Sicherheitszugriffskontrolle zu überprüfen, gibt es einen Sprachausfall "außerhalb des Bandes" von normalem Code, der systematisch Sicherheit einspeisen oder sich in Routinen anmelden kann, in denen sie nicht nativ vorhanden sind so, dass, obwohl Ihr Code es nicht liefert - es erledigt ist.

Ein konkreteres Beispiel ist das Betriebssystem, das Zugriffskontrollen für eine Datei bereitstellt. Ein Softwareprogramm muss nicht nach Zugriffsbeschränkungen suchen, da das zugrunde liegende System dies für ihn tut.

Wenn Sie der Meinung sind, dass Sie nach meiner Erfahrung AOP benötigen, müssen Sie tatsächlich mehr Zeit und Mühe in ein angemessenes Metadatenmanagement in Ihrem System investieren, wobei der Schwerpunkt auf einem durchdachten Struktur- / Systemdesign liegt.

Vom Frühling in Aktion kopiert

AOP wird häufig als eine Technik definiert, die die Trennung von Bedenken in einem Softwaresystem fördert. Systeme bestehen aus mehreren Komponenten, die jeweils für eine bestimmte Funktionalität verantwortlich sind. Oft tragen diese Komponenten jedoch auch zusätzliche Verantwortlichkeiten, die über ihre Kernfunktionalität hinausgehen. Systemdienste wie Protokollierung, Transaktionsmanagement und Sicherheit finden häufig Eingang in Komponenten, deren Kernverantwortung etwas anderes ist. Diese Systemdienste werden allgemein als Querschnittsthemen bezeichnet, da sie dazu neigen, mehrere Komponenten in einem System zu erfassen.

Der Vollständigkeit halber aus einem Duplikat kopiert (Summer):

Klassen- und Methodenattribute in .NET sind eine Form der aspektorientierten Programmierung. Sie dekorieren Ihre Klassen / Methoden mit Attributen. Hinter den Kulissen fügt dies Ihrer Klasse / Methode Code hinzu, der die bestimmten Funktionen des Attributs ausführt. Wenn Sie beispielsweise eine Klasse als serialisierbar markieren, kann sie automatisch zur Speicherung oder Übertragung an ein anderes System serialisiert werden. Andere Attribute markieren möglicherweise bestimmte Eigenschaften als nicht serialisierbar und werden automatisch im serialisierten Objekt weggelassen. Die Serialisierung ist ein Aspekt, der von anderem Code im System implementiert und durch Anwendung eines Attributs "Konfiguration" (Dekoration) auf Ihre Klasse angewendet wird.

Mit AOP können Aktionen ausgeführt werden, die nicht mit der Geschäftslogik Ihrer App zusammenhängen, z. B. Protokollierung, Caching usw. Diese Aktionen können in einem separaten Teil Ihrer App abgelegt und dann in der gesamten Anwendung wiederverwendet werden. Es gibt normalerweise zwei Möglichkeiten, dies zu erreichen. Automatisches Injizieren von Code durch einen Präprozessor vor / nach einer Methode oder Anhängen von Proxy-Klassen, die einen Methodenaufruf abfangen und dann Dinge vor / nach einem Methodenaufruf ausführen können.

Hier ist ein Beispiel in .Net. Es verwendet Proxy-Klassen, um Methodenaufrufe abzufangen und Code vor oder nach saif-Methodenaufrufen auszuführen.

Aspektorientierte Programmierung (AOP) in .NET Core und C # mit AutoFac und DynamicProxy

Es gibt ein Beispiel für AOP, es wurde Feder-AOP als Beispiel verwendet. Das Beispiel ist recht einfach zu verstehen.

Das Spring AOP-Framework (Aspect-Oriented Programming) wird verwendet, um Querschnittsthemen in Aspekten zu modularisieren. Vereinfacht ausgedrückt ist es nur ein Interceptor, um einige Prozesse abzufangen. Wenn beispielsweise eine Methode ausgeführt wird, kann Spring AOP die ausführende Methode entführen und vor oder nach der Methodenausführung zusätzliche Funktionen hinzufügen.

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

AOP ist eine Möglichkeit, Ihre Anwendung besser für Funktionen zu modularisieren, die sich über mehrere Grenzen erstrecken. AOP ist eine weitere Möglichkeit, diese Funktionen zu kapseln und der Einzelverantwortung zu folgen, indem diese Querschnittsthemen (Protokollierung, Fehlerbehandlung usw.) aus den Hauptkomponenten Ihrer Anwendung entfernt werden. Bei sachgemäßer Verwendung kann AOP im Laufe der Zeit zu einer höheren Wartbarkeit und Erweiterbarkeit Ihrer Anwendung führen.