Qu'est-ce qu'une programmation orientée aspect?

Je comprends la programmation orientée objet et j'écris des programmes OO depuis longtemps. Les gens semblent parler de programmation orientée aspect, mais je n'ai jamais vraiment appris ce que c'est ni comment l'utiliser. Quel est le paradigme de base?

Cette question est liée, mais ne la pose pas tout à fait:

Programmation orientée aspect vs programmation orientée objet

AOP résout le problème des préoccupations transversales , qui seraient tout type de code qui est répété dans différentes méthodes et ne peut normalement pas être complètement refactorisé dans son propre module, comme avec la journalisation ou la vérification. Donc, avec AOP, vous pouvez laisser ces choses hors du code principal et les définir verticalement comme ceci:

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

Et puis un aspect-tisserand est utilisé pour compiler le code dans ceci:

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

Malheureusement, il semble être étonnamment difficile de rendre l'AOP vraiment utile dans une organisation de taille moyenne à grande. (Prise en charge de l'éditeur, sentiment de contrôle, le fait que vous commenciez par les choses moins importantes menant à la pourriture de code, aux personnes rentrant chez elles dans leur famille, etc.)

J'ai mis mes espoirs dans la programmation orientée composite , ce qui est de plus en plus réaliste. Il se connecte à de nombreuses idées populaires et vous donne quelque chose de vraiment cool.

Regardez une mise en œuvre à venir ici: qi4j.org/

PS. En fait, je pense que l'une des beautés de l'AOP est également son talon d'Achille: son non intrusif, permettant aux gens de l'ignorer s'ils le peuvent, il sera donc traité comme une préoccupation secondaire dans la plupart des organisations.

Copié à partir d'un doublon pour être complet (Einstein):

Les exemples classiques sont la sécurité et la journalisation. Au lieu d'écrire du code dans votre application pour consigner l'occurrence de x ou vérifier l'objet z pour le contrôle d'accès de sécurité, il y a un langage "hors bande" de code normal qui peut systématiquement injecter de la sécurité ou se connecter à des routines qui ne les ont pas nativement. de telle sorte que même si votre code ne le fournit pas, il est pris en charge.

Un exemple plus concret est le système d'exploitation fournissant des contrôles d'accès à un fichier. Un programme logiciel n'a pas besoin de vérifier les restrictions d'accès car le système sous-jacent le fait pour lui.

Si vous pensez que vous avez besoin d'AOP dans mon expérience, vous devez réellement investir plus de temps et d'efforts dans la gestion appropriée des métadonnées au sein de votre système en mettant l'accent sur une conception structurelle / des systèmes bien pensée.

Copié de Spring in Action

L'AOP est souvent défini comme une technique qui favorise la séparation des préoccupations dans un système logiciel. Les systèmes sont composés de plusieurs composants, chacun responsable d'une fonctionnalité spécifique. Mais souvent, ces composants portent également des responsabilités supplémentaires au-delà de leur fonctionnalité de base. Les services système tels que la journalisation, la gestion des transactions et la sécurité se retrouvent souvent dans des composants dont les principales responsabilités sont autre chose. Ces services système sont communément appelés préoccupations transversales car ils tendent à traverser plusieurs composants d'un système.

Copié à partir d'un doublon pour être complet (Buzzer):

Les attributs de classe et de méthode dans .NET sont une forme de programmation orientée aspect. Vous décorez vos classes / méthodes avec des attributs. Dans les coulisses, cela ajoute du code à votre classe / méthode qui exécute les fonctions particulières de l'attribut. Par exemple, le marquage d'une classe sérialisable permet de la sérialiser automatiquement pour le stockage ou la transmission à un autre système. D'autres attributs peuvent marquer certaines propriétés comme non sérialisables et celles-ci seront automatiquement omises de l'objet sérialisé. La sérialisation est un aspect implémenté par un autre code du système et appliqué à votre classe par l'application d'un attribut "configuration" (décoration).

L'AOP peut être utilisé pour effectuer des actions qui ne sont pas liées à la logique métier de votre application, telles que la journalisation, la mise en cache, etc. Ces actions peuvent être placées dans une partie distincte de votre application, puis réutilisées dans toute l'application. Il existe généralement deux façons d'y parvenir. Injecter du code automatiquement par un préprocesseur avant / après une méthode, ou attacher des classes proxy qui interceptent un appel de méthode et peuvent ensuite exécuter des choses avant / après un appel de méthode.

Voici un exemple dans .Net. Il utilise des classes proxy pour intercepter les appels de méthode et exécuter du code avant ou après les appels de méthode saif.

Programmation orientée aspect (AOP) dans .NET Core et C # à l'aide d'AutoFac et de DynamicProxy

Il y a un exemple d'AOP, il a utilisé le ressort AOP comme exemple. L'exemple est assez facile à comprendre.

Le cadre Spring AOP (Aspect-Oriented Programming) est utilisé pour modulariser les aspects transversaux des aspects. En termes simples, c'est juste un intercepteur pour intercepter certains processus, par exemple, lorsqu'une méthode est exécutée, Spring AOP peut détourner la méthode d'exécution et ajouter des fonctionnalités supplémentaires avant ou après l'exécution de la méthode.

Référence: http://www.mkyong.com/spring/spring-aop-examples-advice/

L'AOP est un moyen de mieux modulariser votre application pour des fonctionnalités qui s'étendent sur plusieurs frontières. L'AOP est un autre moyen d'encapsuler ces fonctionnalités et de suivre la responsabilité unique en supprimant ces préoccupations transversales (journalisation, gestion des erreurs, etc.) des principaux composants de votre application. Lorsqu'il est utilisé de manière appropriée, l'AOP peut conduire à des niveaux plus élevés de maintenabilité et d'extensibilité dans votre application au fil du temps.