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.

Custom Tag is a user-defined JSP language element. When it is contained in JSP page and it will translate into a servlet, the custom tag is converted to opertions on an object called a tag handler. The web container then invokes those operations when the JSP page’s servlet is executed.

If we want to create a custom tag, what we need to do is simply extend SimpleTagSupport class and override the doTag() method, where you can place your code to generate content for the tag.

Let’s getting started to create a custom tag now.
As you can see below, consider we want to create two tag, one is user tag with name and isMale attribute, another is system tag with size attribute.

1
2

<custom:user name="user1" isMale="true"/>
<custom:system size="1024"/>

Usage

Objects.equal(Object, Object)
Invoking this method then it will avoid the risking of NullPointerException when we need to compare two object whether they equal.

1
2
3

Objects.equal("a", "a"); // return true;
Objects.equal(null, "a"); // return false;
Objects.equal(null, null); // return true;