I understand object oriented programming, and have been writing OO programs for a long time. People seem to talk about aspect-oriented programming, but I've never really learned what it is or how to use it. What is the basic paradigm?
This question is related, but doesn't quite ask it:
AOP addresses the problem of cross-cutting concerns, which would be any kind of code that is repeated in different methods and can't normally be completely refactored into its own module, like with logging or verification. So, with AOP you can leave that stuff out of the main code and define it vertically like so:
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();
}
}
}
And then an aspect-weaver is used to compile the code into this:
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;
}
Unfortunately, it seems to be surprisingly difficult to make AOP really useful in a normal mid-large size organization. (Editor support, sense of control, the fact that you start with the not-so-important things leading to code-rot, people going home to their families, etc.)
I put my hopes to composite oriented programming, which is something more and more realistic. It connects to many popular ideas and gives you something really cool.
Look at an up and coming implementation here: qi4j.org/
PS. Actually, I think that one of the beauties with AOP is also its achilles heel: Its non-intrusive, letting people ignore it if they can, so it will be treated as a secondary concern in most organizations.
Copied from Spring in Action
AOP is often defined as a technique that promotes separation of concerns in a software system. Systems are composed of several components, each responsible for a specific piece of functionality. But often these components also carry additional responsibilities beyond their core functionality. System services such as logging, transaction management, and security often find their way into components whose core responsibilities is something else. These system services are commonly referred to as cross-cutting concerns because they tend to cut across multiple components in a system.
Copied from a duplicate for completeness (Einstein):
The classic examples are security and logging. Instead of writing code within your application to log occurance of x or check object z for security access control there is a language contraption "out of band" of normal code which can systematically inject security or logging into routines that don't nativly have them in such a way that even though your code doesn't supply it -- its taken care of.
A more concrete example is the operating system providing access controls to a file. A software program does not need to check for access restrictions because the underlying system does that work for it.
If you think you need AOP in my experience you actually really need to be investing more time and effort into appropriate meta-data management within your system with a focus on well thought structural / systems design.
Copied from a duplicate for completeness (Buzzer):
Class and method attributes in .NET are a form of aspect-oriented programming. You decorate your classes/methods with attributes. Behind the scenes this adds code to your class/method that performs the particular functions of the attribute. For example, marking a class serializable allows it to be serialized automatically for storage or transmission to another system. Other attributes might mark certain properties as non-serializable and these would be automatically omitted from the serialized object. Serialization is an aspect, implemented by other code in the system, and applied to your class by the application of a "configuration" attribute (decoration) .
There is an example of AOP, it used spring AOP as an example. The example is quite easy to understand.
Spring AOP (Aspect-oriented programming) framework is used to modularize cross-cutting concerns in aspects. Put it simple, it’s just an interceptor to intercept some processes, for example, when a method is execute, Spring AOP can hijack the executing method, and add extra functionality before or after the method execution.
Reference: http://www.mkyong.com/spring/spring-aop-examples-advice/
AOP is a way to better modularize your application for functionality that spans across multiple boundaries. AOP is another way to encapsulate these features and follow Single Responsiblity by moving these cross-cutting concerns (logging, error handling, etc.) out of the main components of your application. When used appropriately AOP can lead to higher levels of maintainability and extensibility in your application over time.
Analogy: Imagine you are building a big and complicated home. In programming paradigm like OOPS, we have different rooms(classes) each with different functionalities(methods) and stuff(data). Now we found out we have security risk in our home. So we create a master plan ie to install CCTV camera to every room of our home. In OOPS, we go to each room, and install CCTV camera in the entrance of the room. Its like doing same task over and over again for every room. But in AOPs, we dont need to do same task over and over again. Instead it allow us to create a plan(called aspects) for installing CCTV and the plan can be weaved in all the room at once. We just need to focus on main design and AOP takes care of adding security cameras wherever we need.
So the key terminologies of AOP are:
Concerns (or cross cutting concerns)
Aspects
Join points
Advice
Another example from which you can understand it easily
Let's say we have to print 'Hello Worlds' to the console. Now we want to log every time this message is printed. In traditional methods like OOPs, we'd go to print statement and add log line (like Console.log("message)). But in AOP, we create an aspect that says "Every time there is print statement, also log it" . We don't touch the original print statement; we just apply our aspect and voila ! Logging is added without changing core code.
Merits:
Demerits:
Our goal in Aspect Oriented Programming is to reduce the amount of boilerplate code.
Let's give an example, we have a service, and in this service, let's first print the service.start() log, then the service transaction log, and finally the standard log.
Our 1.log process and 3.log process are the same under the package, so we can reduce boirplate code writing by using it as Cross Cutting.
What is Aspect Oriented Programming?
AOP is an approach that helps reduce the complexity of the software and increase modularity. The purpose of modularization here is to separate the non-functional code, that is, the intersecting interests, used in many parts of the system during the application, into small pieces (Separation of Cross Cutting Concerns).In this way, the structures that will be used throughout the application are abstracted from the system and encapsulated. It allows it to be used in many places. In general, it can be said that AOP helps to make the existing system better rather than solving a problem.
At this point, we can perform common operations and reduction operations here.
What are the benefits of AOP?
