In this type of Advice. This service executed when the logic method throws exceptions. To create Throws Advice, we should implement the interface called ThrowsAdvice.

ThrowsAdvice is provided by org.springframework.aop.* package. But it has not any method we need to override.

In this blog, let us talk about Around Advice. There are some few points about it.

• Around Advice is combination of Before Advice and After Advice.
• In a single Around Advice we can implement both before and after services.
• Note, Around Advice is not given by spring framework, it is from Open Source implementation called AOP alliance.
• Around Advice can be used by any framework which supports AOP.
• Around Advice can access the return value of business method and it can modify the value and it can return a different value back to the client, as return type is Object, but in the After Advice its not possible right, as its return type is void.

Advice is the implementation of the cross-cutting functionality. An Adivce provides the code for implementation of the service.

There are four types of Advice:

• Before Advice
• After Advice
• Around Advice
• Throws Advice

As we know the Aspect is just the name of the cross-cutting functionality, not the implementation. So what’s the implementation of the cross-cutting functionality? It’s called Advice. An Advice provides the code for implementation of the service. It is like Logging service, Logging is a Aspect and Advice denotes the implementation of Log4j.

An Aspect represent the name of a cross-cutting functionality, it’s only name not implementation.

Let us see the example.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

public class MyLogicClass
{
	public void logicOne() {
		//This is my logic for one.

		//Call Authentication Service 
		//Call Logging Service
		//Call Transcation Service
		//Call Email Service
	}

	public void logicTwo() {
		//This is my logic for two.

		//Call Authentication Service 
		//Call Logging Service
		//Call Transcation Service
		//Call Email Service
	}
}

What is AOP?, AOP stand for Aspect Oriented Programming. It’s very important module for Spring framework. In the enterprise level application programming we used to add different types of services to our application at runtime automatically, like logging, email, transaction, authentication services. These actions we called cross-cutting functionalities. AOP do this job.

As we know, we can use jdbc to access database in java programming. And now let us use jdbc in spring. The spring framework reduces developer handlers any accessing database exception, because it deal with them internally. The spring framework integrated the jdbctemplate, they are org.springframework.jdbc.datasource.DriverManagerDataSource and org.springframework.jdbc.core.JdbcTemplate.

And here we use the hsqldb to act as our memory database. You can go to here to look at it. we use the Maven tools to management our project. the dependencies is:

Ordering is Guava’s fluent Comparator class and implements Comparator interface. It can be used to build complex comparators and apply them to collections of objects.

Okay, so let’s getting started. Firstly, we declared a String type List:

1
2
3
4
5
6

private List<String> locations = Lists.newArrayList(
        "Guang zhou",
        "Cheng du",
        "",
        "Shang hai"
);

We will use this locations variable later.