O que é programação orientada a aspectos?

Entendo programação orientada a objetos e escrevo programas OO há muito tempo. As pessoas parecem falar sobre programação orientada a aspectos, mas eu nunca aprendi realmente o que é ou como usá-lo. Qual é o paradigma básico?

Esta questão está relacionada, mas não é bem assim:

Programação Orientada a Aspectos vs. Programação Orientada a Objetos

O AOP soluciona o problema de preocupações transversais , que seriam qualquer tipo de código repetido em métodos diferentes e que normalmente não pode ser completamente refatorado em seu próprio módulo, como registro ou verificação. Portanto, com o AOP, você pode deixar esse material fora do código principal e defini-lo verticalmente da seguinte maneira:

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 então um tecelão de aspecto é usado para compilar o código para isso:

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

Infelizmente, parece ser surpreendentemente difícil tornar a AOP realmente útil em uma organização normal de médio e grande porte. (Suporte ao editor, senso de controle, o fato de você começar com coisas não tão importantes que levam ao apodrecimento do código, as pessoas voltando para casa para suas famílias etc.)

Coloco minhas esperanças na programação orientada composta , que é algo cada vez mais realista. Ele se conecta a muitas idéias populares e oferece algo muito legal.

Veja uma implementação em andamento aqui: qi4j.org/

PS. Na verdade, acho que uma das belezas da AOP também é o calcanhar de Aquiles: não é intrusivo, deixa as pessoas ignorá-lo, se puderem, por isso será tratado como uma preocupação secundária na maioria das organizações.

Copiado de uma duplicata para completude (Einstein):

Os exemplos clássicos são segurança e log. Em vez de escrever código em seu aplicativo para registrar a ocorrência de x ou verificar o objeto z para controle de acesso à segurança, existe uma ferramenta de linguagem "fora da banda" do código normal que pode injetar sistematicamente a segurança ou fazer login em rotinas que não os possuem nativamente de tal maneira que, mesmo que seu código não o forneça, é resolvido.

Um exemplo mais concreto é o sistema operacional que fornece controles de acesso a um arquivo. Um programa de software não precisa verificar restrições de acesso, porque o sistema subjacente funciona para ele.

Se você acha que precisa de AOP em minha experiência, realmente precisa investir mais tempo e esforço no gerenciamento apropriado de metadados dentro do seu sistema, com foco em projetos estruturais / de sistemas bem pensados.

Copiado do Spring in Action

AOP é frequentemente definida como uma técnica que promove a separação de preocupações em um sistema de software. Os sistemas são compostos de vários componentes, cada um responsável por uma parte específica da funcionalidade. Mas muitas vezes esses componentes também carregam responsabilidades adicionais além da funcionalidade principal. Os serviços do sistema, como registro em log, gerenciamento de transações e segurança, costumam encontrar componentes cujas responsabilidades principais são outra coisa. Esses serviços do sistema são comumente referidos como preocupações transversais porque tendem a atravessar vários componentes em um sistema.

Copiado de uma duplicata para conclusão (Campainha):

Os atributos de classe e método no .NET são uma forma de programação orientada a aspectos. Você decora suas classes / métodos com atributos. Nos bastidores, isso adiciona código à sua classe / método que executa as funções específicas do atributo. Por exemplo, marcar uma classe como serializável permite que ela seja serializada automaticamente para armazenamento ou transmissão para outro sistema. Outros atributos podem marcar determinadas propriedades como não serializáveis ​​e elas seriam automaticamente omitidas do objeto serializado. Serialização é um aspecto, implementado por outro código no sistema e aplicado à sua classe pela aplicação de um atributo de "configuração" (decoração).

O AOP pode ser usado para executar ações que não estão relacionadas à lógica comercial do seu aplicativo, como log, cache, etc. Essas ações podem ser colocadas em uma parte separada do seu aplicativo e depois reutilizadas em todo o aplicativo. Normalmente existem duas maneiras de conseguir isso. Injetando código automaticamente por um pré-processador antes / depois de um método ou anexando classes de proxy que interceptam uma chamada de método e podem executar as coisas antes / depois de uma chamada de método.

Aqui está um exemplo em .Net. Ele usa classes proxy para interceptar chamadas de método e executar código antes das chamadas de método após saif.

Programação Orientada a Aspectos (AOP) no .NET Core e C # usando AutoFac e DynamicProxy

Há um exemplo de AOP, que usou a AOP de primavera como exemplo. O exemplo é bastante fácil de entender.

A estrutura AOP da Primavera (programação orientada a aspectos) é usada para modularizar questões transversais em aspectos. Simplificando, é apenas um interceptador para interceptar alguns processos, por exemplo, quando um método é executado, o Spring AOP pode seqüestrar o método em execução e adicionar funcionalidade extra antes ou depois da execução do método.

Referência: http://www.mkyong.com/spring/spring-aop-examples-advice/

AOP é uma maneira de modularizar melhor seu aplicativo para funcionalidade que se estende por vários limites. AOP é outra maneira de encapsular esses recursos e seguir a Responsabilidade Única, movendo essas preocupações transversais (registro, tratamento de erros etc.) dos principais componentes do seu aplicativo. Quando usado adequadamente, o AOP pode levar a níveis mais altos de manutenção e extensibilidade em seu aplicativo ao longo do tempo.