<div dir="ltr" style="text-align: justify;">
<div dir="ltr" style="text-align: justify;">
<div dir="ltr" style="text-align: justify;">
<div dir="ltr" style="text-align: justify;">
<div dir="ltr" style="text-align: justify;">
<div dir="ltr" style="text-align: justify;">In this chapter we will see that Implementation of AOP based on XML Schema and also look the relative code in annotation based. Before using the AOP we have to add namespaces of AOP to the configuration file as following.</div>
<div style="background-color: #f2f9fc; border: 1px solid #c9e6f2; border-radius: 3px; padding: 16px; line-height: 1.45;"><span style="color: red; font-size: x-large; text-align: center;"><b>Popular Tutorials</b></span></p>
<ul style="text-align: left;">
<li><b><a href="https://dineshonjava.com/spring-tutorial/"><em><strong>Spring Tutorial</strong> </em></a></b></li>
<li><b><a href="https://dineshonjava.com/spring-web-mvc-framework-chapter-38/"><strong><em>Spring MVC Web Tutorial </em></strong></a></b></li>
<li><b><a href="https://dineshonjava.com/introduction-to-spring-boot-a-spring-boot-complete-guide/"><strong>Spring Boot Tutorial</strong> </a></b></li>
<li><b><a href="https://dineshonjava.com/spring-security-take-baby-step-to-secure/"><em>Spring Security Tutorial</em></a></b></li>
<li><b><a href="https://dineshonjava.com/spring-aop-tutorial-with-example-aspect-advice-pointcut-joinpoint/"><em>Spring AOP Tutorial</em></a></b></li>
<li><b><a href="https://dineshonjava.com/using-spring-jdbc-framework-chapter-32/"><em>Spring JDBC Tutorial</em></a></b></li>
<li><b><a href="https://dineshonjava.com/spring-hateoas-hypermedia-driven-restful-web-service/"><em><strong>Spring HATEOAS </strong></em></a></b></li>
<li><b><a href="https://dineshonjava.com/microservices-with-spring-boot/"><em><strong>Microservices with Spring Boot</strong></em></a></b></li>
<li><b><a href="https://dineshonjava.com/jax-rs-web-service-tutorial/"><strong><em>REST Webservice</em> </strong></a></b></li>
<li><b><a href="https://dineshonjava.com/core-java-baby-step-to-be-best-java-ian/"><em><strong>Core Java </strong></em></a></b></li>
<li><b><a href="https://dineshonjava.com/hibernate-3-on-baby-steps/"><em><strong>Hibernate Tutorial</strong></em></a></b></li>
<li><b><a href="https://dineshonjava.com/spring-batch-process-with-example/"><strong><em>Spring Batch</em> </strong></a></b></li>
</ul>
</div>
<pre class="highlight"><;beans xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p" xmlns:> 
</div> 
You will also need following AspectJ libraries on the CLASSPATH of your application. These libraries are available in the 'lib' directory of an AspectJ installation, otherwise you can download them from the internet. 
 
1. aspectjrt.jar 
2. aspectjweaver.jar 
3. aspectj.jar 
<h2><b> 
Declaring an aspect</b></h2> 
An aspect is declared using the <b><;aop:aspect>;</b> element, and the backing bean is referenced using the ref attribute as follows: 
<pre class="highlight"><;bean class="com.sdnext.aop.tutorial.aspectJ.LoggingAspect" id="loggingAspect">; 
 .... 
<;/bean>; 
<;aop:config>; 
 <;aop:aspect id="loggingAspect" ref="loggingAspect">; 
 .... 
 <;/aop:aspect>; 
<;/aop:config>; 
</pre>
<p>Here "loggingAspect" will be configured and dependency injected just like any other Spring bean as you have seen in previous chapters.</p>
<h2><b>Declaring a pointcut </b></h2>
<p>A pointcut helps in determining the join points (ie methods) of interest to be executed with different advices. While working with XML Schema based configuration, pointcut will be defined as follows:</p>
<pre class="highlight"><;aop:config>; 
 <;aop:aspect id="loggingAspect" ref="loggingAspect">; 
 
 <;aop:pointcut expression="execution(* com.sdnext.aop.service.*.*(..))" id="businessService">; <;/aop:pointcut>; 
 ... 
 <;/aop:aspect>; 
<;/aop:config>; 
 
<;bean class="com.sdnext.aop.tutorial.aspectJ.LoggingAspect" id="loggingAspect">; 
 .... 
<;/bean>; 
</pre>
<p>The following example defines a <b>pointcut </b>named '<b>businessService</b>' that will match the execution of all getter as like getName() etc method available in Circle class under the package com.sdnext.aop.tutorial:</p>
<pre class="highlight"><;aop:config>; 
 <;aop:aspect id="loggingAspect" ref="loggingAspect">; 
 
 <;aop:pointcut expression="execution(* com.sdnext.aop.tutorial.Circle.getName(..))" id="businessService">;<;/aop:pointcut>; 
 .... 
 <;/aop:aspect>; 
<;/aop:config>; 
 
<;bean class="com.sdnext.aop.tutorial.aspectJ.LoggingAspect" id="loggingAspect">; 
 .... 
<;/bean>; 
</pre>
<h2><b><br />
Declaring advices</b></h2>
<p>You can declare any of the <b>five advices inside an <;aop:aspect>;...<;/aop:aspect>; using the <;aop: name="name">;...<;/aop:>;element</b> as given below:<br />
<b><br />
1.before advice- <;aop:before>;<;/aop:before >;<br />
2.after advice- <;aop:after>;<;/aop:after>;<br />
3.after-returning advice- <;aop:after-returning>;<;/aop:after-returning>;<br />
4.after-throwing advice- <;aop:after-throwing>;<;/aop:after-throwing>;<br />
5.around advice- <;aop:around>;<;/aop:around>;<br />
</b></p>
<pre class="highlight"><;aop:config>; 
 <;aop:aspect id="loggingAspect" ref="loggingAspect">; 
 <;aop:pointcut expression="execution(* com.sdnext.aop.service.*.*(..))" id="businessService">; 
 <;/aop:pointcut>; 
 <;!-- a before advice definition -->; 
 <;aop:before method="someRequiredTask" pointcut-ref="businessService">; 
 ..... 
 <;/aop:before>; 
 <;!-- an after advice definition -->; 
 <;aop:after method="someRequiredTask" pointcut-ref="businessService">; 
 ...... 
 <;/aop:after>; 
 <;!-- an after-returning advice definition -->; 
 <;!--The someRequiredTask method must have parameter named retVal -->; 
 <;aop:after-returning method="someRequiredTask" pointcut-ref="businessService" returning="retVal">; 
 ..... 
 <;/aop:after-returning>; 
 <;!-- an after-throwing advice definition -->; 
 <;!--The someRequiredTask method must have parameter named ex -->; 
 <;aop:after-throwing method="someRequiredTask" pointcut-ref="businessService" throwing="ex">; 
 .... 
 <;/aop:after-throwing>; 
 <;!-- an around advice definition -->; 
 <;aop:around method="someRequiredTask" pointcut-ref="businessService">; 
 ... 
 <;/aop:around>; 
 ..... 
 <;/aop:aspect>; 
<;/aop:config>; 
 
<;bean class="com.sdnext.aop.tutorial.aspectJ.LoggingAspect" name="loggingAspect">; 
 .... 
<;/bean>; 
</pre>
<p>You can use same <b>someRequiredTask </b>or different methods for different advices. These methods will be defined as a part of aspect module.<br />
we can also declare the advice as following ways also.</p>
<pre class="highlight"><;aop:config>; 
 <;aop:aspect id="loggingAspect" ref="loggingAspect">; 
 <;aop:after method="stringArgumentsMethods" pointcut="args(name)">;<;/aop:after>; 
 <;aop:after-returning method="afterReturningAdvice" pointcut="args(name)" returning="returnString">;<;/aop:after-returning>; 
 <;aop:after-throwing method="exceptionMethod" pointcut="args(name)" throwing="ex">; 
<;/aop:after-throwing>; 
 <;aop:around method="myArroundMethod" pointcut="within(com.sdnext.aop.tutorial.model.Circle)">;<;/aop:around>; 
 <;aop:before method="loggingAdvice" pointcut="execution(public * get*(..))">;<;/aop:before>; 
 <;/aop:aspect>; 
<;/aop:config>; 
 
<;bean class="com.sdnext.aop.tutorial.aspectJ.LoggingAspect" name="loggingAspect">; 
 .... 
<;/bean>; 
</pre>
</div>
<p>Let see how to use the <b>AspectJ </b>annotation with differences advice in the below interface methods and also <b>we compare the XML schema vs Aspect Annotation.</b></p>
<pre class="highlight">package com.sdnext.aop.aspectj.tutorial; 
 
public interface Employee{ 
 
 void addEmployee(); 
 
 String addEmployeeReturnValue(); 
 
 void addEmployeeThrowException() throws Exception; 
 
 void addEmployeeAround(String name); 
}</pre>
<h2><b><br />
1. AspectJ <;aop:before>; = @Before</b></h2>
<pre class="highlight">package com.sdnext.aop.tutorial.aspectJ; 
 
import org.aspectj.lang.JoinPoint; 
import org.aspectj.lang.annotation.Aspect; 
import org.aspectj.lang.annotation.Before; 
 
@Aspect 
public class LoggingAspect 
{ 
//Joint point means a place where advice are applied to target methods 
@Before("execution(com.sdnext.aop.aspectj.tutorial.Employee.addEmployee(..))") 
public void loggingBoforeAdvice(JoinPoint joinPoint) 
{ 
 System.out.println(joinPoint.toString()); 
 //.... 
 //.... 
 System.out.println("Advice run. ADD method is called"); 
} 
</pre>
<p>Its Equivalent functionality writing in XML, with <b><;aop:before>;</b>.</p>
<pre class="highlight"><;!-- Aspect -->; 
<;bean class="com.sdnext.aop.tutorial.aspectJ.LoggingAspect" name="loggingAspect">; 
 <;/bean>; 
<;aop:config>; 
 <;aop:aspect id="loggingAspect" ref="loggingAspect">; 
 <;!-- @Before -->; 
 <;aop:pointcut expression="execution(*com.sdnext.aop.aspectj.tutorial.Employee.addEmployee(..))" id="pointCutBefore">;<;/aop:pointcut>; 
 
 <;aop:before method="loggingBoforeAdvice" pointcut-ref="pointCutBefore">;<;/aop:before>; 
 
 <;/aop:aspect>; 
 
<;/aop:config>; 
</pre>
<h2><b><br />
2. AspectJ <;aop:after>; = @After</b></h2>
<pre class="highlight">package com.sdnext.aop.tutorial.aspectJ; 
 
import org.aspectj.lang.JoinPoint; 
import org.aspectj.lang.annotation.Aspect; 
import org.aspectj.lang.annotation.After; 
 
@Aspect 
public class LoggingAspect 
{ 
//Joint point means a place where advice are applied to target methods 
@After("execution(com.sdnext.aop.aspectj.tutorial.Employee.addEmployee(..))") 
public void loggingAfterAdvice(JoinPoint joinPoint) 
{ 
 System.out.println(joinPoint.toString()); 
 //.... 
 //.... 
 System.out.println("Advice run. ADD method is called"); 
} 
</pre>
<p>Its Equivalent functionality writing in XML, with <b><;aop:after>;</b>.</p>
<pre class="highlight"><;!-- Aspect -->; 
<;bean class="com.sdnext.aop.tutorial.aspectJ.LoggingAspect" name="loggingAspect">; 
 <;/bean>; 
<;aop:config>; 
 <;aop:aspect id="loggingAspect" ref="loggingAspect">; 
 <;!-- @After -->; 
 <;aop:pointcut expression="execution(*com.sdnext.aop.aspectj.tutorial.Employee.addEmployee(..))" id="pointCutAfter">;<;/aop:pointcut>; 
 
 <;aop:before method="loggingAfterAdvice" pointcut-ref="pointCutAfter">;<;/aop:before>; 
 
 <;/aop:aspect>; 
 
<;/aop:config>; 
</pre>
<h2><b><br />
3. AspectJ <;aop:after-returning>; = @AfterReturning</b></h2>
<pre class="highlight">package com.sdnext.aop.tutorial.aspectJ; 
 
import org.aspectj.lang.JoinPoint; 
import org.aspectj.lang.annotation.Aspect; 
import org.aspectj.lang.annotation.AfterReturning; 
 
@Aspect 
public class LoggingAspect 
{ 
//Joint point means a place where advice are applied to target methods 
@AfterReturning( 
 pointcut = "execution(* com.sdnext.aop.aspectj.tutorial.Employee.addEmployeeReturnValue(..))", 
 returning= "result") 
 public void logAfterReturning(JoinPoint joinPoint, Object result) { 
 //... 
 } 
 
} 
</pre>
<p>Its Equivalent functionality writing in XML, with <b><;aop:after-returning>;</b>.</p>
<pre class="highlight"><;!-- Aspect -->; 
<;bean class="com.sdnext.aop.tutorial.aspectJ.LoggingAspect" name="loggingAspect">; 
 <;/bean>; 
<;aop:config>; 
 <;aop:aspect id="loggingAspect" ref="loggingAspect">; 
 <;!-- @AfterReturning -->; 
 <;aop:pointcut expression="execution(* com.sdnext.aop.aspectj.tutorial.Employee.addEmployeeReturnValue(..))" id="pointCutAfterReturning">;<;/aop:pointcut>; 
 
 <;aop:after-returning method="logAfterReturning" pointcut-ref="pointCutAfterReturning" returning="result">; <;/aop:after-returning>; 
 
 <;/aop:aspect>; 
 
<;/aop:config>; 
</pre>
<h2><b><br />
4. AspectJ <;aop:after-throwing>; = @AfterThrowing</b></h2>
<pre class="highlight">package com.sdnext.aop.tutorial.aspectJ; 
 
import org.aspectj.lang.JoinPoint; 
import org.aspectj.lang.annotation.Aspect; 
import org.aspectj.lang.annotation.AfterThrowing; 
 
@Aspect 
public class LoggingAspect 
{ 
//Joint point means a place where advice are applied to target methods 
@AfterThrowing( 
 pointcut = "execution(* com.sdnext.aop.aspectj.tutorial.Employee.addEmployeeThrowException(..))", 
 throwing= "error") 
 public void logAfterThrowing(JoinPoint joinPoint, Throwable error) { 
 //... 
 } 
} 
</pre>
<p>Its Equivalent functionality writing in XML, with <b><;aop:after-throwing>;</b>.</p>
<pre class="highlight"><;!-- Aspect -->; 
<;bean class="com.sdnext.aop.tutorial.aspectJ.LoggingAspect" name="loggingAspect">; 
 <;/bean>; 
<;aop:config>; 
 <;aop:aspect id="loggingAspect" ref="loggingAspect">; 
 <;!-- @AfterThrowing -->; 
 <;aop:pointcut expression="execution(* com.sdnext.aop.aspectj.tutorial.Employee.addEmployeeThrowException(..))" id="pointCutAfterThrowing">;&;lt;/ 
aop:pointcut&;gt; 
 <;aop:after-thrwoing method="logAfterThrowing" pointcut-ref="pointCutAfterThrowing" throwing="error">;<;/aop:after-thrwoing>; 
 
 <;/aop:pointcut>;<;/aop:aspect>; 
 
<;/aop:config>; 
</pre>
<h2><b><br />
5. AspectJ <;aop:after-around>; = @Around</b></h2>
<pre class="highlight">package com.sdnext.aop.tutorial.aspectJ; 
 
import org.aspectj.lang.JoinPoint; 
import org.aspectj.lang.annotation.Aspect; 
import org.aspectj.lang.annotation.Around; 
 
@Aspect 
public class LoggingAspect 
{ 
//Joint point means a place where advice are applied to target methods 
@Around("execution(* com.sdnext.aop.aspectj.tutorial.Employee.addEmployeeAround(..))") 
 public void logAround(ProceedingJoinPoint joinPoint) throws Throwable { 
 //... 
 } 
} 
</pre>
<p>Its Equivalent functionality writing in XML, with <b><;aop:around>;</b>.</p>
<pre class="highlight"><;!-- Aspect -->; 
<;bean class="com.sdnext.aop.tutorial.aspectJ.LoggingAspect" name="loggingAspect">; 
 <;/bean>; 
<;aop:config>; 
 <;aop:aspect id="loggingAspect" ref="loggingAspect">; 
 <;!-- @Around -->; 
 <;aop:pointcut expression="execution(* com.sdnext.aop.aspectj.tutorial.Employee.addEmployeeAround(..))" id="pointCutAround">;<;/aop:pointcut>; 
 
 <;aop:around method="logAround" pointcut-ref="pointCutAround">;<;/aop:around>; 
 <;/aop:aspect>; 
 
<;/aop:config>; 
</pre>
<h2><b><br />
Spring AOP XML Schema Based Example</b></h2>
<p>To understand above mentioned concepts related to <b>XML Schema Based AOP</b>, let us write an example which will implement few of the <b>advices</b>. To write our example with few advices, let us have working Eclipse IDE in place and follow the following steps to create a Spring application:</p>
<table class="src" border="1">
<tbody>
<tr>
<th class="fivepct">Step</th>
<th>Description</th>
</tr>
<tr>
<td>1</td>
<td>Create a java project with a name <b><i>SpringAOPDemo</i></b> and create a package <b><i>com.dineshonjava.sdnext.aop.aspectJ</i> </b>under the <b>src</b> folder in the created project.</td>
</tr>
<tr>
<td>2</td>
<td>Add required Spring libraries using <b><i>Add External JARs</i></b> <i>or User Liberaries </i>option <i>.</i></td>
</tr>
<tr>
<td>3</td>
<td>Add Sppring AOP secific libraries <b>aspectjrt.jar, aspectjweaver.jar</b> and <b>aspectj.jar</b> in the project.</td>
</tr>
<tr>
<td>4</td>
<td>Create Java classes <b>LoggingAspect</b>, <b>Employee</b> and <b>AopMain</b> under the <b><i>com.dineshonjava.sdnext.aop.aspect, </i></b><b><i><b><i>com.dineshonjava.sdnext.aop.emp, </i></b> </i></b><b><i>com.dineshonjava.sdnext.aop</i></b> package respectively.</td>
</tr>
<tr>
<td>5</td>
<td>Create Beans configuration file <b><i>spring.xml</i></b> under the <b>src</b> folder.</td>
</tr>
<tr>
<td>6</td>
<td>The final step is to create the content of all the Java files and Bean Configuration file and run the application as explained below.</td>
</tr>
</tbody>
</table>
<div class="separator" style="clear: both; text-align: center;"><img class="alignnone" src="https://dineshonjava.com/wp-content/uploads/2012/07/aopdemo.jpg" width="640" height="575" border="0" /></div>
<p>Here is the content of <b>LoggingAspect</b><b>.java</b> file. This is actually a sample of aspect module which defines methods to be called at various points.</p>
</div>
<p><b>LoggingAspect.java</b></p>
<pre class="highlight">package com.dineshonjava.sdnext.aop.aspect; 
 
import java.util.Arrays; 
 
import org.aspectj.lang.JoinPoint; 
import org.aspectj.lang.ProceedingJoinPoint; 
 
public class LoggingAspect { 
 public void logBeforeAdvice(JoinPoint joinPoint) { 
 
 System.out.println("logBeforeAdvice() is running!"); 
 System.out.println("hijacked : " + joinPoint.getSignature().getName()); 
 System.out.println("******"); 
 } 
 
 public void logAfterAdvice(JoinPoint joinPoint) { 
 
 System.out.println("logAfterAdvice() is running!"); 
 System.out.println("hijacked : " + joinPoint.getSignature().getName()); 
 System.out.println("******"); 
 
 } 
 
 public void logAfterReturningAdvice(JoinPoint joinPoint, Object result) { 
 
 System.out.println("logAfterReturningAdvice() is running!"); 
 System.out.println("hijacked : " + joinPoint.getSignature().getName()); 
 System.out.println("Method returned value is : " + result); 
 System.out.println("******"); 
 
 } 
 
 public void logAfterThrowingAdvice(JoinPoint joinPoint, Throwable error) { 
 
 System.out.println("logAfterThrowingAdvice() is running!"); 
 System.out.println("hijacked : " + joinPoint.getSignature().getName()); 
 System.out.println("Exception : " + error); 
 System.out.println("******"); 
 
 } 
 
 public void logAroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable { 
 
 System.out.println("logAroundAdvice() is running!"); 
 System.out.println("hijacked method : " + joinPoint.getSignature().getName()); 
 System.out.println("hijacked arguments : " + Arrays.toString(joinPoint.getArgs())); 
 
 System.out.println("Around before is running!"); 
 joinPoint.proceed(); 
 System.out.println("Around after is running!"); 
 
 System.out.println("******"); 
 
 } 
} 
</pre>
<p><b>Employee.java</b></p>
<pre class="highlight">package com.dineshonjava.sdnext.aop.emp; 
 
public interface Employee { 
 
 void addEmployee(); 
 
 String addEmployeeReturnValue(); 
 
 void addEmployeeThrowException() throws Exception; 
 
 void addEmployeeAround(String name); 
} 
</pre>
<p><b>EmployeeImpl.java</b></p>
<pre class="highlight">package com.dineshonjava.sdnext.aop.emp.impl; 
 
import com.dineshonjava.sdnext.aop.emp.Employee; 
 
public class EmployeeImpl implements Employee { 
 
 public void addEmployee() { 
 System.out.println("addEmployee() is running "); 
 } 
 
 public String addEmployeeReturnValue() { 
 System.out.println("addEmployeeReturnValue() is running "); 
 return "abc"; 
 } 
 
 public void addEmployeeThrowException() throws Exception { 
 System.out.println("addEmployeeThrowException() is running "); 
 throw new Exception("Generic Error"); 
 } 
 
 public void addEmployeeAround(String name) { 
 System.out.println("addEmployeeAround() is running, args : " + name); 
 } 
} 
</pre>
<p><b>spring.xml</b></p>
<pre class="highlight"><;beans xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p" xmlns:> 
<b>AopMain.java</b> 
<pre class="highlight">package com.dineshonjava.sdnext.aop; 
 
import org.springframework.context.ApplicationContext; 
import org.springframework.context.support.ClassPathXmlApplicationContext; 
 
import com.dineshonjava.sdnext.aop.emp.Employee; 
 
public class AopMain { 
 public static void main(String[] args) throws Exception { 
 
 ApplicationContext appContext = new ClassPathXmlApplicationContext("spring.xml"); 
 
 Employee employee = (Employee) appContext.getBean("employee"); 
 employee.addEmployee(); 
 
 //employee.addEmployeeReturnValue(); 
 
 //employee.addEmployeeThrowException(); 
 
 //employee.addEmployeeAround("dinesh"); 
 
 } 
} 
</pre>
<p>Once you are done with creating source and bean configuration files, let us run the application. If everything is fine with your application, this will print the following message:</p>
<div style="background-color: #ff99cc; border-width: thin; border: solid;"><b>Output:</b><br />
Nov 4, 2012 8:43:29 PM org.springframework.context.support.AbstractApplicationContext prepareRefresh<br />
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@be2358: display name [org.springframework.context.support.ClassPathXmlApplicationContext@be2358]; startup date [Sun Nov 04 20:43:29 IST 2012]; root of context hierarchy<br />
Nov 4, 2012 8:43:30 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions<br />
INFO: Loading XML bean definitions from class path resource [spring.xml]<br />
Nov 4, 2012 8:43:30 PM org.springframework.context.support.AbstractApplicationContext obtainFreshBeanFactory<br />
INFO: Bean factory for application context [org.springframework.context.support.ClassPathXmlApplicationContext@be2358]: org.springframework.beans.factory.support.DefaultListableBeanFactory@1b383e9<br />
Nov 4, 2012 8:43:30 PM org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons<br />
INFO: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@1b383e9: defining beans [employee,org.springframework.aop.config.internalAutoProxyCreator,logAspect,<br />
org.springframework.aop.aspectj.AspectJPointcutAdvisor#0,<br />
org.springframework.aop.aspectj.AspectJPointcutAdvisor#1,<br />
org.springframework.aop.aspectj.AspectJPointcutAdvisor#2,<br />
org.springframework.aop.aspectj.AspectJPointcutAdvisor#3,<br />
org.springframework.aop.aspectj.AspectJPointcutAdvisor#4,<br />
pointCutBefore,pointCutAfter,pointCutAfterReturning,pointCutAfterThrowing,pointCutAround];<br />
root of factory hierarchy<br />
<b>logBeforeAdvice() is running!</b><br />
<b>hijacked : addEmployee</b><br />
<b>******</b><br />
<b>addEmployee() is running </b><br />
<b>logAfterAdvice() is running!</b><br />
<b>hijacked : addEmployee</b><br />
<b>******</b></div>
<p> ;</p>
<div style="background-color: #f2f9fc; border-radius: 3px; border: 1px solid #c9e6f2; line-height: 1.45; padding: 16px;"><span style="color: red; font-size: x-large; text-align: center;"><b>Spring AOP Related Posts</b></span></p>
<ul>
<li><b><a href="https://dineshonjava.com/spring-aop-interview-questions-and-answers/"><span style="color: red;">Spring AOP Interview Questions and Answers</span></a></b></li>
<li><b><a href="https://dineshonjava.com/introduction-to-aop-in-spring/"><span style="color: red;">Spring AOP-Introduction to Aspect Oriented Programming</span></a></b></li>
<li><b><a href="https://dineshonjava.com/spring-aspect-annotation/"><span style="color: red;">@Aspect Annotation in Spring</span></a></b></li>
<li><b><a href="https://dineshonjava.com/after-advice-type-and-around-advice/"><span style="color: red;">Advices in Spring AOP </span></a></b></li>
<li><b><a href="https://dineshonjava.com/joinpoints-and-advice-arguments-chapter/"><span style="color: red;">Spring AOP JoinPoints and Advice Arguments</span></a></b></li>
<li><b><a href="https://dineshonjava.com/pointcuts-and-wildcard-expressions/"><span style="color: red;">Spring AOP-Declaring pointcut Expressions with Examples</span></a></b></li>
<li><b><a href="https://dineshonjava.com/aop-xml-configuration-chapter-30/"><span style="color: red;">Spring AOP XML configuration</span></a></b></li>
<li><b><a href="https://dineshonjava.com/spring-aop-aspectj-before-annotation-advice-example/"><span style="color: red;"> Spring AOP AspectJ @Before Annotation Advice Example<br />
</span></a></b></li>
<li><b><a href="https://dineshonjava.com/spring-aop-before-advice-example-using-xml-config/"><span style="color: red;"> Spring AOP Before Advice Example using XML Config</span></a></b></li>
<li><b><a href="https://dineshonjava.com/spring-aop-aspectj-after-annotation-advice-example/"><span style="color: red;"> Spring AOP AspectJ @After Annotation Advice Example</span></a></b></li>
<li><b><a href="https://dineshonjava.com/spring-aop-after-advice-example-using-xml-config/"><span style="color: red;"> Spring AOP After Advice Example using XML Config</span></a></b></li>
<li><b><a href="https://dineshonjava.com/spring-aop-aspectj-after-returning-annotation-advice-example/"><span style="color: red;"> Spring AOP AspectJ @AfterReturning Annotation Advice Example</span></a></b></li>
<li><b><a href="https://dineshonjava.com/spring-aop-after-returning-advice-example-using-xml-config/"><span style="color: red;"> Spring AOP After-Returning Advice Example using XML Config</span></a></b></li>
<li><b><a href="https://dineshonjava.com/spring-aop-aspectj-after-throwing-annotation-advice-example/"><span style="color: red;"> Spring AOP AspectJ @AfterThrowing Annotation Advice Example</span></a></b></li>
<li><b><a href="https://dineshonjava.com/spring-aop-after-throwing-advice-example-using-xml-config/"><span style="color: red;"> Spring AOP After Throwing Advice Example using XML Config</span></a></b></li>
<li><b><a href="https://dineshonjava.com/spring-aop-aspectj-around-annotation-advice-example/"><span style="color: red;"> Spring AOP AspectJ @Around Annotation Advice Example</span></a></b></li>
<li><b><a href="https://dineshonjava.com/spring-aop-around-advice-example-using-xml-config/"><span style="color: red;"> Spring AOP Around Advice Example using XML Config</span></a></b></li>
<li><b><a href="https://dineshonjava.com/writing-first-aspectj-program-in-spring/"><span style="color: red;">Spring AOP Writing First AspectJ Program in Spring</span></a></b></li>
<li><b><a href="https://dineshonjava.com/understanding-aop-proxies-chapter-31/"><span style="color: red;">Spring AOP Proxies in Spring</span></a></b></li>
<li><b><a href="https://dineshonjava.com/spring-aop-transaction-management-in/"><span style="color: red;"> Spring AOP Transaction Management in Hibernate</span></a></b></li>
<li><b><a href="https://dineshonjava.com/transaction-management-in-spring/"><span style="color: red;">Spring Transaction Management</span></a></b></li>
<li><b><a href="https://dineshonjava.com/declarative-transaction-management/"><span style="color: red;">Spring Declarative Transaction Management Example</span></a></b></li>
<li><b><a href="https://dineshonjava.com/spring-aop-ordering-of-aspects-with-example/"><span style="color: red;">Spring AOP-Ordering of Aspects with Example</span></a></b></li>
</ul>
<p> ;</p>
</div>
<p><b style="color: #274e13;"> </b></p>
<div style="text-align: center;"><b><;<; </b><b><b></b><b><a href="https://dineshonjava.com/writing-first-aspectj-program-in-spring/">First Aspect Program in Spring</a></b></b><b> |<a href="https://dineshonjava.com/spring-tutorial/">index</a>| <a href="https://dineshonjava.com/spring-aspect-annotation/">@AspectJ based Example</a>>;>;</b></div>
</div>
<p> ;</p>
</div>
<div class="wp-post-navigation"> 
									 <div class="wp-post-navigation-pre"> 
									 <a href="https://dineshonjava.com/writing-first-aspectj-program-in-spring/">Previous</a> 
									 </div> 
									 <div class="wp-post-navigation-next"> 
									 <a href="https://dineshonjava.com/interview-questions-on-spring/">Next</a> 
									 </div> 
									</div>
<script type="text/javascript">
jQuery(document).ready(function($) {
 $.post('https://dineshonjava.com/wp-admin/admin-ajax.php', {action: 'mts_view_count', id: '644'});
});
</script>
Strategy Design Patterns We can easily create a strategy design pattern using lambda. To implement…
Decorator Pattern A decorator pattern allows a user to add new functionality to an existing…
Delegating pattern In software engineering, the delegation pattern is an object-oriented design pattern that allows…
Technology has emerged a lot in the last decade, and now we have artificial intelligence;…
Managing a database is becoming increasingly complex now due to the vast amount of data…
Overview In this article, we will explore Spring Scheduler how we could use it by…