What is Aspect-Oriented Programming?

In summary, Aspect-Oriented Programming or Aspect-Oriented Progrmming (AOP) is a programming model that enables proper separation of responsibilities, considering features that are essential to a group of objects, but are not directly responsible for them.

AOP is said to be orthogonal because it usually involves concepts that are layer-independent and have no direct relationship to the functional requirements of a system.

Examples of application of AOP are: log generation, Access Control and exceptional treatments, transactions.

For example, the method below (in Java) contains fictitious business logic and various treatments needed in any enterprise system: transaction, security, and logging. I tried to make the example so as not to hurt principles and good practices of object orientation.

See method:

//Inversão de Controle: dependências são recebidas por parâmetros
void processarOperacao(TransactionManager transacao, LogManager log, SecurityManager seguranca, OperacaoDAO dao, Operacao operacao) {
    try {

        //segurança
        if (seguranca.usuarioEstaLogado()) {
            log.info("Falha de segurança"); //log
            throw new AcessoNegadoException();
        }

        //transação
        transacao.begin();
        processamentoComplexoOperacao(operacao);
        dao.salvarOperacao(operacao);
        transacao.commit();
        log.info("Sucesso"); //log

    } catch (ErroNegocioException e) {
        //tratamento excepcional
        log.error("Falha", e); //log
        transacao.rollback(); 
    }
}

The main problems with the above code are:

• it will repeat itself in all system methods.
• 99% of the code deals with orthogonal things, that is, business logic is lost in the midst of various technical issues.

With AOP we can let the developer focus on logic and delegate these other details to a framework or container with AOP support.

Let's now see an example using AOP:

//dependências
@Inject OperacaoDao;

@UsuarioDeveEstarLogado //segurança
@Transactional //transação
void processarOperacao(Operacao operacao) {

    processamentoComplexoOperacao(operacao);
    dao.salvarOperacao(operacao);

}

Did you see the difference? Go explicit:

• dependencies : a framework injects the dependencies, so you don't need "dirty" signatures or constructors, that is, with parameters that are foreign to logic.
• Security : frameworks can intercept methods, so I assume your framework will intercept the call to all methods that have the @UsuarioDeveEstarLogado annotation and execute a logic you write in one place.
• transaction : the framework creates automatically the transaction when it finds the annotation @Transactional. It also handles commit or rollback depending on whether or not the method threw an exception.
• Logging : the AOP framework can automatically intercept and log all method calls and exceptions that occur.