My two cents on aspect-oriented programming

Aspect-oriented programming isolates the concerns of your application, reduces code clutter, and improves the maintainability and readability of your code

Aspect Oriented Programming

AOP (aspect-oriented programming) is a programming style that can be adopted to define certain policies that in turn are used to define and manage the cross-cutting concerns in an application. In essence, it's a programming paradigm that enables your application to be adaptable to changes.

So, when you take advantage of AOP in your applications, you can increase the modularity of your application through separation of concerns. You can use AOP to reduce code clutter by improving the readability and maintainability of your code.

It should be noted that AOP is just a new programming paradigm -- it doesn't replace OOP in any way. Rather, it complements OOP by providing you another way to achieve modularity and also reduce code clutter.

In AOP, an aspect may be defined as the modularization of a concern. Hence, this style of programming is named aspect oriented programming. In OOP you can take advantage of classes to achieve modularity. On the contrary, you can achieve modularity in AOP through aspects.

The essence of AOP is encapsulating functionalities that are common while at the same time enabling your application to leverage those functionalities as need be. Such common functionalities or cross-cutting concerns include security management, logging, notifications, transaction management, exception management, etc. Some of the popular AOP frameworks include: PostSharp, Spring framework, Castle Windsor, Microsoft Unity framework, Policy Injection Block, etc.

Getting familiar with the AOP terminologies

When working with AOP, you should be familiar with some of the key concepts of it. These include the following:

  • Aspect: A cross-cutting concern or a reusable module. You can have one or more aspects in an application.
  • Introduction: A feature that's used to declare additional methods and attributes for a particular type.
  • Join Point: A point where you can plug an aspect in.
  • Advice: The action that is performed at a particular join point. It's also used to define the action that should be performed preceding or succeeding a method execution.
  • Weaving: Provides you solution to your tangled code. It enables you to link different aspects with other objects of the application. Note that depending on when weaving will happen, you can have compile time, load time or run-time weaving.
  • Target Object: A target object may be defined as one that is advised by one or more aspects in your application.
  • Pointcut: Specifies the weaving rules, i.e., it is used to define the join point where a particular advice can be applied in your application.

Why should I use AOP anyway?

OOP promotes reusability and flexibility of code already. So, why then do you need AOP? AOP is a programming paradigm that has all the benefits of OOP as well. Added to this, you can promote loose coupling and enable your application to use pluggable aspects as and when needed sans any change in your application's code. In using AOP, you can focus on the business logic of your application while at the same time weave the aspects to the business logic. One of the major benefits of using AOP is that you would just need to write your aspects once and then you can reuse it wherever you need to in your application. So, AOP is a great way to reduce the complexity of the source code of your application and make your code clean. The benefits of AOP include:

  • Reduced code clutter
  • Reduced code redundancy
  • Easier code maintenance
  • Faster development
  • Improved code readability

How do I achieve AOP in my application?

To implement AOP in your applications, the first thing you need to do is isolate the aspects in your application from the business logic. The most important thing that you should keep in mind while designing the aspects is that they should be independent and shouldn't have any dependency on the application. You should be able to test the aspects independent of each other as well. Next, you should apply those aspects to the application's source code by weaving them wherever they are needed by the application. One of the ways in which you can implement AOP in your applications is through the usage of attributes.

Copyright © 2016 IDG Communications, Inc.