Advertisement

---

Top

< Prev

Next >

In this tutorial, we are going to explain how to configure the Spring Framework to work with AspectJ using some AspectJ Annotations. For this, we are going to declare and define some important AspectJ properties such as aspect, pointcut, joinpoint and some simple advices using AspectJ Annotation, such as -

• @Aspect
• @Pointcut
• @Before
• @AfterReturning

Creating the Java class - MarathonRunner

We are going to create a java class named MarathonRunner within the decodejava package and this class contains -

• A String property named name.
• A String property named age.

Besides this, we are also going to define a couple of getter and setter methods within this class to set the above mentioned properties of MarathonRunner class.

Besides these getter and setter methods, we are going to define two more methods i.e. marathonBegins() and marathonEnds(), which are going to become our joinpoints. Before the execution of these methods(joinpoints), we are going to apply the pointcuts and advices of AspectJ (using AspectJ Annotations in another Java class), later on.

package decodejava;

public class MarathonRunner
{
String name;
int age;

//Getter method for age
public int getAge() {
	return age;
}

//Setter method for age
public void setAge(int age) {
	this.age = age;
}


//Getter method for name
public String getName()
{
	return name;
}

//Setter method for name
public void setName(String name) 
{
	this.name = name;
}

public void marathonBegins()
{
System.out.println("Marathon runner has started the race");
}

public void marathonEnds()
{
System.out.println("Marathon runner has finished the race");
}

}

Class defining pointcuts and advices

Next, we are going to add another Java class named MarathonTimeTracker and in which we are going to define a few AspectJ properties, using AspectJ annotations, such as - pointcut, joinpoints and advices, using AspectJ Annotation, such as -

• @Aspect - This annotation is used to specify an aspect java class.
• @Pointcut- This annotation is used to specify a pointcut using an expression.
• @Before - This annotation is used to specify a before advice.
• @AfterReturning - This annotation is used to specify an after-returning advice.





package decodejava;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;

@Aspect
public class MarathonTimeTracker
{
	
	
	//Creating the first PointCut
	@Pointcut("execution(public void MarathonRunner.marathonBegins())")
	public void trackingBeginsPointCut1() 
	{
	}

	//Creating the second PointCut
	@Pointcut ("execution(void MarathonRunner.marathonEnds())")
	public void trackingEndsPointCut2()
	{
	}


	@Before("trackingBeginsPointCut1()")
	public void trackingBegins(JoinPoint jp)
	{
	System.out.println("Marathon has started - " + jp.getSignature());
	System.out.println("Tracking the marathon has begun");
	}


	@AfterReturning("trackingEndsPointCut2()")
	public void trackingEnds(JoinPoint jp)
	{
	System.out.println("Marathon has ended - " + jp.getSignature());
	System.out.println("Tracking the marathon has ended");
	}


}






Advertisement






Adding the Utility class that calls the Spring API


Next, we are going to create another class named - Utility, which is a simple java class.

Utility.java

package decodejava;	

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

public class Utility
{
public static void main(String[] ar)
{
	
	ApplicationContext context = new FileSystemXmlApplicationContext("classpath:config.beans.xml");
	MarathonRunner mr = context.getBean("MarathonRunnerBean", MarathonRunner.class);
	System.out.println("Name of the Marathon Runner - " + mr.getName());
	System.out.println("Age of the Marathon Runner - " + mr.getAge());
	mr.marathonBegins();
	mr.marathonEnds();
}
}



The Utility class uses the ApplicationContext container(an interface) of Spring Framework by creating its instance using its implemented class FileSystemXmlApplicationContext, which loads the configuration xml file - config.beans.xml and does the following -


• Reads XML to create the MarathonRunner bean named MarathonRunnerBean and initiate its property name and age with a value by calling its setter methods i.e. setName() and setAge().



• Using MarathonRunnerBean, the methods of MarathonRunner class are called i.e. getName(), getAge(), marathonBegins() and marathonEnds().







Adding a configuration file


Next, we are going to add a configuration file to our project. This configuration document is an Extensible Markup Language(XML) file, ending with .xml extension and we are going to name file as config.beans.xml.

In this file, we have configured a MarathonRunner bean with a unique id and with its property named name and age. This properties will be assigned a value by the Spring Container using their respective setter methods, when the MarathonRunner bean is created by it using the configuration xml file.


config.beans.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:util="springframework.org/schema/util"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/context/spring-context.xsd
       ">
           
<bean id="MarathonRunnerBean" class="decodejava.MarathonRunner">
<property name="name" value="Runner1"></property>
<property name="age" value="27"></property>
</bean>

<bean id="MarathonTimeTrackerBean" class="decodejava.MarathonTimeTracker">

<bean class="org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator"></bean>>

</beans>




This mapping document has a parent <beans> tag as the root element and its individual child elements, where each child element stats with a <bean> tag, containing all the attributes such as -


• The id attribute within the <bean> element defines a unique id associated with the bean.
• The class attribute within the <bean> element defines the name of the class of this bean.



The property child element in <bean> tag refers to a property within the MarathonRunner class.
• The name child attribute refers to the name of a property in the MarathonRunner class i.e. name and age.
• The value child attribute refers to the value assigned to a specific property.







Adding JARs




• We are going to add some JARs files to our Java project, such as -
  • The JARs are associated with the Spring Framework.
  • The JAR associated with the AspectJ and to use its Annotations.
  These JARs are required in order to successfully execute this Spring project as we are working with both Spring Framework and AspectJ using AspectJ Annotations.
  
  
  
  1. All these JARs associated with the Spring Framework are included in its installation folder named libs(within our Spring installation folder). So, we need to add all the JARs in the libs folder to our build path of our Java project.
  
  
  Note : Those who don't know how to add JARs to the build path of your Java project in Eclipse IDE, please refer to our section Adding JARs to your Spring project in Eclipse.
  
  
  
  
  2. Next, we are going to add a JAR file named aspectjweaver to the build path of our Java project. This JAR make the AspectJ work weaves or integrate our Spring project with using AspectJ Annotations.
     
     This JAR file is included in the folder named lib(within our AspectJ installation folder). So, we need to add all this JAR to the build path of our Java project as well.
  
  
  
  
  
  



Directory Structure of Project






The picture above depicts how and where to arrange classes and interfaces comprising this Spring Project, in a specific directory structure.

Project Folder - SpringWithAspectJByAnnotation is the name of our Project and it is a top-level directory.


This project folder contains a package of our project i.e. decodejava containing three classes -
• A POJO class named MarathonRunner.java.
• Another POJO class named MarathonTimeTracker.java class.
• A class that calls the Spring Framework into action i.e. Utility.java.



• Besides this, the project folder also contains a configuration file i.e. config.beans.xml, used to configure the beans of classes in the project.
  
  
• The project folder also contains all the needed Spring JARs present in the libs folder of Spring Framework installation.







Execution


Finally, after executing the Utility class, you will get the following output within the Console window. This output shown below, shows how the Utility class has used the ApplicationContext container of Spring Framework to load the configuration xml file - config.beans.xml, in order to access the beans specified in it, instantiate the MarathonRunner class and applying the aspects through advices i.e. @Before, @AfterReturning defined in MarathonTimeTracker.

These advices defined in MarathonTimeTracker are called and executed before executing the associated method of MarathonRunner class using AspectJ Annotations with Spring Framework.




Aug 03, 2018 6:14:47 PM org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.FileSystemXmlApplicationContext@1eb44e46: startup date [Fri Aug 03 18:14:47 2018]; root of context hierarchy
Aug 03, 2018 6:14:48 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [config.beans.xml]
Name of the Marathon Runner - Runner1
Age of the Marathon Runner - 27
Marathon has started - void decodejava.MarathonRunner.marathonBegins()
Tracking the marathon has begun
Marathon runner has started the race
Marathon runner has finished the race
Marathon has ended - void decodejava.MarathonRunner.marathonEnds()
Tracking the marathon has ended



And, this concludes configuring Spring Framework with AspectJ using AspectJ Annotations.






Please share this article -






< Prev
Next >
< Download & Install AspectJ
Spring-AspectJ with Schema >



Advertisement