
In my last article about **Aspect Oriented Programming** (AOP), I explained [how to use Spring AOP for profiling method execution time][1]. When the article was [posted][2] in DZone, it got a comment from [an user][3] saying that

[1]: https://veerasundar.com/blog/spring-aop-example-profiling-method-execution-time-tutorial "Spring AOP Example: Profiling method execution time tutorial"
[2]: http://www.dzone.com/links/spring_aop_example_profiling_method_execution_tim.html
[3]: http://www.dzone.com/links/users/profile/388907.html

> Profiling and logging seem to be to only imaginable AOP use cases.

But, I think **it is not**. Because AOP is an extensive area where a lot of examples can be shown as use cases of AOP. Here, 'Use cases' are nothing but the **cross cutting concerns** in your application. That is, the functionalities that are used by many part of your application. Logging and Profiling are the best examples and can be easily explained for the cross cutting concerns. That is why in most of the AOP tutorials you can see a logging example or profiling.

Anyway, I tried to do some search on the various AOP cross-cutting concerns (i.e. the _use cases_) that can be found in an J2EE applications. Here is the list of them. Feel free to add if I'm missing/wrongly added something.

## List of AOP Use Cases or Cross cutting concerns:

- **Transaction Management** - in an enterprise application, you can manage the transactional requests using AOP. For example, using the *Around *advice, you can wrap the request processing method and if the method fails for some reason, in your Advice, you can roll back the particular transaction.
- **Access control or Security **- in case you want to restrict the access to your method to a set of users, you can add these checks to the *Before *advice and verify the access credentials of the users before letting them to access your methods.
- **Managing Quotas for your API **- if your API is being used by many third party applications with predefined quotas, you can limit the access based the usage in your AOP advice. If the usage is below the allowed limit, the Advice can let the user to call the API or blocks it otherwise. This is something similar to the Google App Engine / Amazon services quota usages. But I'm not sure how Google/Amazon has implemented the quota limiting.
- **Exception Wrapping** - if you want to wrap a exception, thrown from your business methods, into a Common exception object and throw it to the top level layers, you can use *After throwing *advice to do the task. For example, if you want to wrap all the SQLExceptions into DAOLayerException object and throw it back to Service layer, instead of doing the exception wrapping in every single DAO method, you can implement the exception wrapping in an _After throwing advice_ and it's done.
- **Logging and Profiling - **off course, how can I leave these two? The evergreen examples(!) for the AOP.

I understand that this list is not an extensive one. So, if you have any more use cases to add this list, please leave a comment.


Use cases of Aspect Oriented Programming

I have already written about the _Spring Aspect Oriented Programming (AOP)_ with the use of simple logging example. But, somehow I felt that the example code was little confusing for the newcomers. So, I decided to write a new Spring AOP example code that explains how to use Spring AOP for profiling method execution time.

## Using Spring AOP to profile method execution time:

The example I chose is very simple: our application has a business class and a business method. We are going to profile how much time does it take to execute the business method. We will use Spring AOP for profiling the execution time. Since, profiling is a best example for _cross cutting concern_, it's a good decision to use Spring AOP for implementing it. I'll explain these in step by step. Meanwhile, you can [download the source code][1](excluding dependent JAR file, for which you can see the download links below).

[1]: http://www.box.net/shared/9nygu7t80t "Download source code for Spring AOP example"

And, here's the library versions I'm using: [Spring 2.5.4][2], JDK 1.6, [Commons-logging-1.0.4][3], [aspectjrt-1.2][4], [aspectjweaver-1.5.3][5].

[2]: http://s3.amazonaws.com/dist.springframework.org/release/SPR/spring-framework-2.5.4.zip "Download Spring 2.5.4 JAR"
[3]: http://mirrors.ibiblio.org/pub/mirrors/maven/commons-logging/jars/commons-logging-1.0.4.jar "Download commons logging"
[4]: http://mirrors.ibiblio.org/pub/mirrors/maven/aspectj/jars/aspectjrt-1.2.jar
[5]: http://mirrors.ibiblio.org/pub/mirrors/maven/aspectj/jars/aspectjweaver-1.5.3.jar

## 1. Setting up the project structure:

Launch your preferred IDE (I use Eclipse) and _Create New Java Project_. And then create the file structure as shown below (off course, no need to follow the package naming convention.

![Spring AOP - Project Structure][7]

[7]: https://veerasundar.com/img/2010/01/spring-aop-project-structure.png "spring-aop-project-structure"

You need to download all the JARs that are in _Referenced Libraries_ and add them to the project's class path. You can find these JARs here: [Spring][8], [Commons-logging][9], [aspectjrt][10], [aspectjweaver][11]. Also, please note that the file **Business.java** is an Interface. Other than this, all other java files are plain Classes.

[8]: http://s3.amazonaws.com/dist.springframework.org/release/SPR/spring-framework-2.5.4.zip "Download Spring"
[9]: http://mirrors.ibiblio.org/pub/mirrors/maven/commons-logging/jars/commons-logging-1.0.4.jar "Download Commons-logging"
[10]: http://mirrors.ibiblio.org/pub/mirrors/maven/aspectj/jars/aspectjrt-1.2.jar "Download AspectJrt"
[11]: http://mirrors.ibiblio.org/pub/mirrors/maven/aspectj/jars/aspectjweaver-1.5.3.jar "download Aspectjweaver"

## 2. Writing our Business Logic:

We will first write our business logic and then we will add Spring AOP to profile our business methods. Open _Business.java_ interface and copy the below code into it.

```java

    package com.veerasundar.spring.aop;

    public interface Business {
            void doSomeOperation();
    }

```

Now, open the *BusinessImpl.java* and copy the below code into it.

```java

    package com.veerasundar.spring.aop;

    public class BusinessImpl implements Business {

            public void doSomeOperation() {
                    System.out.println("I do what I do best, i.e sleep.");
                    try {
                            Thread.sleep(2000);
                    } catch (InterruptedException e) {
                            System.out.println("How dare you to wake me up?");
                    }
                    System.out.println("Done with sleeping.");
            }

    }

```

I guess this code is self explanatory. Our business method just sleeps for 2 seconds (good business, isn't it!?) and then write some text on the console.

## 3. Writing a Spring Aspect to profile business method:

Lets write a Aspect which will profile our business method. I'm gonna use **@Around** advice (Lost in the jargons? [Spring AOP basics][12]). Open the *BusinessProfiler.java* file and copy the below code into it.

 [12]: http://static.springsource.org/spring/docs/2.5.4/reference/aop.html#aop-introduction-defn "Spring AOP basics"

```java

    package com.veerasundar.spring.aop;

    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Pointcut;

    @Aspect
    public class BusinessProfiler {

            @Pointcut("execution(* com.veerasundar.spring.aop.*.*(..))")
            public void businessMethods() { }

            @Around("businessMethods()")
            public Object profile(ProceedingJoinPoint pjp) throws Throwable {
                    long start = System.currentTimeMillis();
                    System.out.println("Going to call the method.");
                    Object output = pjp.proceed();
                    System.out.println("Method execution completed.");
                    long elapsedTime = System.currentTimeMillis() - start;
                    System.out.println("Method execution time: " + elapsedTime + " milliseconds.");
                    return output;
            }

    }

```

Here's what this code does:

1.  Using *@AspectJ* annotation, we have declared that this class is an Aspect.
2.  Using *@Pointcut* annotation, we have defined a pointcut that will match the execution of all public method inside com.veerasundar.spring.aop package**.** [[read more about pointcut][13]]
3.  Using *@Around* annotation, we have defined a Around advice which will be invoked *before* and *after* our business method. i.e. @Around advice will wrap our business method. As you can see in the above code, *pjp.proceed()***.** This is when our business method gets called from @Around advice.

 [13]: http://static.springsource.org/spring/docs/2.5.4/reference/aop.html#aop-pointcuts "Spring Aspect Oriented Programming - Pointcut examples"

## 4. Configuring Spring AOP and @AspectJ support:

Open the *applicationContext.xml* file and copy the below code into it.

```xml

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

        
        <aop:aspectj-autoproxy />

        <bean id="businessProfiler" class="com.veerasundar.spring.aop.BusinessProfiler" />
        <bean id="myBusinessClass" class="com.veerasundar.spring.aop.BusinessImpl" />
    </beans>

```

Here's what we are doing in the above XML file:

1.  We have added the [required AOP schemas][14] on the top of the XML file.
2.  Using , we've enabled the @AspectJ support to our application.
3.  And then we defined two normal Spring beans - one for our Business class and the other for Business Profiler (i.e. our aspect).

 [14]: http://static.springsource.org/spring/docs/2.5.4/reference/xsd-config.html#xsd-config-body-schemas-aop "XML Schemas required for Spring AOP support"

That's it. With all the above code is done, we have successfully added Spring AOP support to our project and configured it. In the next step, lets test our code.

## 5. Testing the Spring AOP profiler:

Open the file *SpringAOPDemo.java* and copy the below lines into it.

```java

    package com.veerasundar.spring.aop;

    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;

    public class SpringAOPDemo {

            /**
             * @param args
             */
            public static void main(String[] args) {
                    ApplicationContext context = new ClassPathXmlApplicationContext(
                                    "applicationContext.xml");
                    Business bc = (Business) context.getBean("myBusinessClass");
                    bc.doSomeOperation();
            }

    }

```

In the above code we are loading our Business bean from Spring Context and then calling our business method. If you run this class, it will produce the following output on the console.

```java

    Going to call the method.
    I do what I do best, i.e sleep.
    Done with sleeping.
    Method execution completed.
    Method execution time: 2000 milliseconds.

```
I hope this tutorial helps you to understand the basics of Spring Aspect Oriented programming. If you have any questions regarding the above example, feel free to leave a comment**.**

Spring AOP Example: Profiling method execution time tutorial


As Java developers, we all knew what is _Object Oriented Programming_. In OOP, a particular functionality (say, payroll calculation) is contained in a single class, thus providing the data encapsulation. So, a OOP system will have more than one objects, each representing a particular functionality, collaborating within themselves. What if, you need a functionality to spread across multiple objects?

Lets take the _logging_. It is sure that each object will be using the logging framework to log the event happenings (or whatever the developer prefer!), by calling the log methods. So, each object will have it's own code for logging. The point here is, the logging functionality requirement is spread across multiple objects (lets call this as **_Cross cutting Concern_**, since it cut across multiple objects). Won't it be nice to have some mechanism to automatically execute the logging code, before executing the methods of several objects?

## The Aspect Oriented Programming:

Welcome to **Aspect Oriented Programming (AOP)**. AOP is _the nice mechanism_ that helps you to insert a piece of code before/after/around any methods of your choice. Using AOP, you can specify what code you want to insert (**_the advise_**) and where you want to insert the code (the **Join Point** (if single place) / **Pointcut **(if multiple place). You can think of the _advise_ as the **interceptor** and the _Pointcut_ as the **methods that are intercepted.**

Thus using AOP, you will be **_weaving_** certain methods around the existing methods. And the existing methods may not even know that a new functionality is getting added. The AOP framework takes care of this weaving.

And it is possible the weave your code either **_before, after or around (the advises)_** executing method. In case of Around advise, you can execute your custom functionality before calling the method, then continuing with the method execution and then executing a custom functionality. Thus, the normal method execution is surrounded by the custom functionality, which is weaved by the AOP framework. Apart from this, executing a custom functionality when ever the called method throws some Exception, is also possible. This is called as **_After throwing advise._**

There are multiple vendors who provide necessary libraries for aspect oriented programming. [AspectJ][1] is one of the most popular and well known framework in the AOP circle. Apart from AspectJ, [Spring also provides supports Java AOP][2]. And, Spring integrates very well with the AspectJ style. I'll be discussing more about the **Spring AOP** in my next article.

[1]: http://www.eclipse.org/aspectj/ "AspectJ - Aspect Oriented Framework"
[2]: http://static.springframework.org/spring/docs/2.5.x/reference/aop.html "AOP Framework from Spring"


#aspect (3)