The Simple application ...
- Search Engine Interface :
SearchEngine.java/*
* Author: Abhi Vuyyuru
*/
package search;
import java.util.List;
public interface SearchEngine {
public List<String> search(String prefix);
} - Search Engine Class :
SearchEngineImpl.java/*
* Author: Abhi Vuyyuru
*/package search;
import java.util.ArrayList;
import java.util.List;
public class SearchEngineImpl implements SearchEngine {
public List<String> search(String prefix) {
System.out.println("In search implementation");
List<String> list = new ArrayList<String>();
list.add(prefix + " result 1");
list.add(prefix + " result 2");
return list;
}
} - Main method:
AopTest.java/*
* Author: Abhi Vuyyuru
*/
package main;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
import search.SearchEngine;
public class AopTest {
public static void main(String[] args) {
ApplicationContext ctx = new FileSystemXmlApplicationContext(
"applicationContext.xml");
SearchEngine searchEngine = (SearchEngine) ctx.getBean("searchEngine");
List<String> searchResults = searchEngine.search("search");
System.out.println("Number of results : " + searchResults.size());
}
}
- Appication Conext : This the spring configuration file for the example.
<?xml version="1.0" encoding="UTF-8"?>
applicationContext.xml
<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"
 xmlns:tx="http://www.springframework.org/schema/tx"
 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
 http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
<!--
<aop:aspectj-autoproxy proxy-target-class="true"/> <bean
 id="adviceObject" class="aop.AspectJAdvice" />
 -->
<aop:config>
<!-- Pointcut for every method invocation -->
<aop:pointcut id="searchEnginePc" expression="execution(* *(..))" />
<!-- Pointcut for every method invocation with a String parameter -->
<aop:pointcut id="pointcutWithParam" expression="execution(* *(..)) and args(prefix)" />
<!-- After returning advice -->
<aop:aspect id="springAspect" ref="adviceObject">
<aop:around pointcut-ref="searchEnginePc" method="aroundAdvice" />
<aop:after-returning pointcut-ref="searchEnginePc"
 method="afterAdvice" />
<aop:before pointcut-ref="pointcutWithParam" method="beforeAdvice" />
</aop:aspect>
</aop:config>
<bean id="adviceObject" class="aop.SpringAdvice" />
<bean id="searchEngine" class="search.SearchEngineImpl" />
</beans>- This xml is used for the default Spring AOP implementation with Java dynamic proxies. Note that the main method is programmed to the SearchEngine interface rather than the concrete class.
Hence, the AOP configuration was set toSearchEngine searchEngine = (SearchEngine) ctx.getBean("searchEngine");<aop:config >
If you have to use the concrete class in your application, as shown below
You have to change the AOP configuration to the followingSearchEngineImpl searchEngine = (SearchEngineImpl) ctx.getBean("searchEngine");<!-- proxy-target-class forces the use of CGLIB proxies, which allows proxying classes in addition to interfaces.-->
This will force the use of CGLIB proxies which allow proxying concrete classes too.
<aop:config proxy-target-class="true"> - The aop-config element defines three different types of advice, around-advice, before advice, and after return advice.
- Before Advice: Applied before a join point. This does not have the ability to prevent jointpoint (method execution) unless it throws an exception. The Before advice in the example uses a pointcut that uses arguments and can be used as a model for applying Advice for methods based on the parameter passed to the methods.
- After Return Advice: Applied after the join points returns without exception.
- Around Advice: Is applied around a join point. Note that the around advice is NOT called "before and after" the join point, but rather "around" the join point. If you look at the code below, the around advice is invoked when the join point is about to execute, but the around advice takes control of the execution. If you do not call the pjp.proceed() method in the following code, the join point will not be invoked.
Around advice has the ability to change the behavior of the join point, and even to stop the join point execution./*
* Applied around a any public method.
*/
public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable {
System.out.println("Around advice before joinpoint");
Object obj = pjp.proceed();
System.out.println("Around advice after running");
return obj;
}
- The Aspect:
AspectJAdvice.java/*
* Author: Abhi Vuyyuru
*/
package aop;
import org.aspectj.lang.ProceedingJoinPoint;
public class SpringAdvice {
/*
* Applied around a any public method, based on XML configuration
*/
public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable {
System.out.println("Around advice before joinpoint");
Object obj = pjp.proceed();
System.out.println("Around advice after running");
return obj;
}
/*
* Applied before the execution of any method which takes a String argument.
* Based on XML configuration
*/
public void beforeAdvice(String prefix) {
System.out.println("Before advice : " + prefix);
}
/*
* Applied after returning, based on XML configuration
*/
public void afterAdvice() {
System.out.println("After Returning advice");
}
} - This xml is used for the default Spring AOP implementation with Java dynamic proxies. Note that the main method is programmed to the SearchEngine interface rather than the concrete class.
