{"id":4075,"date":"2026-01-21T05:09:40","date_gmt":"2026-01-21T10:09:40","guid":{"rendered":"https:\/\/www.h2kinfosys.com\/blog\/?p=4075"},"modified":"2026-01-21T05:09:42","modified_gmt":"2026-01-21T10:09:42","slug":"spring-aop","status":"publish","type":"post","link":"https:\/\/www.h2kinfosys.com\/blog\/spring-aop\/","title":{"rendered":"Spring AOP"},"content":{"rendered":"\n

Aspect-Oriented Programming is a paradigm that allows adding additional behavior to existing code without its modification. That additional code usually is needed for multiple types and objects. It can be a logic for transaction management, logging, or security. It is calling cross-cutting concerns. Spring framework has its own library to make aspects possible (Spring AOP). We can call aspect-oriented programming<\/a> as an evolution of the decorator design pattern. But AOP provides you the possibility to enhance classes with much greater flexibility than the decorator. You can even do your manipulations with code from third-party sources.<\/p>\n\n\n\n

You don’t need a special compilation process for Spring AOP because it is implemented in pure Java. The approach of Spring AOP differs from that of most other AOP frameworks. It provides close integration between AOP implementation and Spring IoC, that help solve common problems in enterprise applications.<\/p>\n\n\n\n

Spring AOP Aspects are creating using normal bean definition syntax.<\/p>\n\n\n\n

But there are some things you cannot do easily with Spring AOP, AspectJ is the best choice in such cases. For example,  advise domain objects. In general, Spring AOP provides a great solution to a lot of enterprise Java application issues. Spring AOP and AspectJ are complementary.<\/p>\n\n\n\n

\"Spring<\/figure>\n\n\n\n

Terminology<\/h2>\n\n\n\n

One of the most important terms of AOP is advice. An action by an aspect at a particular join-point.<\/p>\n\n\n\n

Join-point is a point of an application, like a method or an exception handling. In Spring AOP a joinpoint is a method execution.<\/p>\n\n\n\n

Pointcut is an expression that corresponds to join-points. Advice runs when the join-point matched by the pointcut. Spring by default is using the AspectJ pointcut expression language<\/p>\n\n\n\n

Types of AOP Advices<\/strong><\/h2>\n\n\n\n

Spring AOP has five types of advice.<\/p>\n\n\n\n

Before advice<\/em>:<\/strong> this type of advice executes before a join point. It cannot prevent execution flow proceeding to the join point (if it does not throw an exception).<\/p>\n\n\n\n

After returning advice:<\/em><\/strong> this advice executes after a normal completion of a join point (if no exception occurred).<\/p>\n\n\n\n

After throwing advice<\/em>:<\/strong> this advice is executed if a method throws an exception.<\/p>\n\n\n\n

After advice<\/em>:<\/strong> this advice is executed normal or exceptional return from a join point.<\/p>\n\n\n\n

Around advice<\/em>:<\/strong> this kind of advice is the most powerful. It surrounds a join point such as a method invocation. This advice can invoke custom behavior before and after the method. It also decides whether to proceed to the join point or to return its own value or throwing an exception.<\/p>\n\n\n\n

All types of advices are implemented as interfaces in AOP and they have a hierarchy. The parent interface is Advice. Interfaces BeforeAdvice, AfterAdvice, and Interceptor extending Advice interface. MethodBeforeAdvice extends the BeforeAdvice interface, AfterReturningAdvice extends the AfterAdvice, ThrowsAdvice interface extends the AfterAdvice, MethodInterceptor interface extends the Interceptor interface and used in around advice.<\/p>\n\n\n\n

Let’s create an example with BeforeAdvisor by implementing MethodBeforeAdvice.<\/p>\n\n\n\n

package<\/strong> edu.example.aop;\n\nimport<\/strong> java.lang.reflect.Method;  \nimport<\/strong> org.springframework.aop.MethodBeforeAdvice;  \n\npublic<\/strong> class<\/strong> BeforeAdviceExecutor implements<\/strong> MethodBeforeAdvice {\n\n@Override\npublic<\/strong> void<\/strong> before(Method method, Object[] args, Object target) throws<\/strong> Throwable {\nSystem.out<\/em><\/strong>.println(\"We are going to run this code before an actual logic\");  \n}\n}\n\nThe class where the advice is used will be simple:\npackage<\/strong> edu.example.aop;\n\npublic<\/strong> class<\/strong> AdviceExample {\n\npublic<\/strong> void<\/strong> method() {\nSystem.out<\/em><\/strong>.println(\"Here is our main logic\");  \n}\n}\n<\/pre>\n\n\n\n
In the XML configuration file, we will create 3 beans:  for AdviceExample class, for Advisor class, and for ProxyFactoryBean <\/a>class. The class ProxyFactoryBean is provided by Spring Framework. It contains a target and an interceptor name. The instance of the AdviceExample class will be our target object and the instance of advisor class will be an interceptor. We can have several interceptors. Here is our configuration file:<\/p>\n\n\n\n
<?xml version=\"1.0\"<\/em> encoding=\"UTF-8\"<\/em>?>\n<beans xmlns=\"http:\/\/www.springframework.org\/schema\/beans\"<\/em>\nxmlns:xsi=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\"<\/em>\nxmlns:aop=\"http:\/\/www.springframework.org\/schema\/aop\"<\/em>\nxsi:schemaLocation=\"http:\/\/www.springframework.org\/schema\/beans<\/em>\n    http:\/\/www.springframework.org\/schema\/beans\/spring-beans-3.0.xsd<\/em>\n    http:\/\/www.springframework.org\/schema\/aop<\/em>\n    http:\/\/www.springframework.org\/schema\/aop\/spring-aop-3.0.xsd \"<\/em>>\n\n<bean id=\"obj\"<\/em> class=\"edu.example.aop.AdviceExample\"<\/em>><\/bean>\n<bean id=\"adviceExecutor\"<\/em>\nclass=\"edu.example.aop.BeforeAdviceExecutor\"<\/em>><\/bean>\n\n<bean id=\"proxy\"<\/em>\nclass=\"org.springframework.aop.framework.ProxyFactoryBean\"<\/em>>\n<property name=\"target\"<\/em> ref=\"obj\"<\/em>><\/property>\n<property name=\"interceptorNames\"<\/em>>\n<list>\n<value>adviceExecutor<\/value>\n<\/list>\n<\/property>\n<\/bean>\n<\/beans><\/pre>\n\n\n\n
The output will be:<\/p>\n\n\n\n
We are going to run this code before an actual logic<\/p>\n\n\n\n
Here is our main logic<\/p>\n\n\n\n
Let’s also create a ThrowsAdvice Example. Here is class with logic:<\/p>\n\n\n\n
package<\/strong> edu.example.aop;\npublic<\/strong> class<\/strong> Validator {  \n    public<\/strong> void<\/strong> validate(int<\/strong> age)throws<\/strong> Exception{  \n        if<\/strong>(age<18){  \n            throw<\/strong> new<\/strong> ArithmeticException(\"Not Valid Age\");  \n        }  \n        else<\/strong>{  \n            System.out<\/em><\/strong>.println(\"Age is good\");  \n        }  \n    }  \n}\n<\/pre>\n\n\n\n
As we already said, we need to implement ThrowsAdvice for this type of interceptor:<\/p>\n\n\n\n
package<\/strong> edu.example.aop;\n\nimport<\/strong> org.springframework.aop.ThrowsAdvice;  \n\npublic<\/strong> class<\/strong> ThrowAdviceExecutor implements<\/strong> ThrowsAdvice {  \n\n    public<\/strong> void<\/strong> afterThrowing(Exception ex){  \n        System.out<\/em><\/strong>.println(\"Exception occured, let's do something\");  \n    }  \n}\n<\/pre>\n\n\n\n
The configuration file will look very similar to the previous:<\/p>\n\n\n\n
<?xml version=\"1.0\"<\/em> encoding=\"UTF-8\"<\/em>?>\n<beans xmlns=\"http:\/\/www.springframework.org\/schema\/beans\"<\/em>\nxmlns:xsi=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\"<\/em>\nxmlns:aop=\"http:\/\/www.springframework.org\/schema\/aop\"<\/em>\nxsi:schemaLocation=\"http:\/\/www.springframework.org\/schema\/beans<\/em>\n    http:\/\/www.springframework.org\/schema\/beans\/spring-beans-3.0.xsd<\/em>\n    http:\/\/www.springframework.org\/schema\/aop<\/em>\n    http:\/\/www.springframework.org\/schema\/aop\/spring-aop-3.0.xsd \"<\/em>>\n\n<bean id=\"obj\"<\/em> class=\"edu.example.aop.Validator\"<\/em>><\/bean>\n<bean id=\"adviceExecutor\"<\/em>\nclass=\"edu.example.aop.ThrowAdviceExecutor\"<\/em>><\/bean>\n\n<bean id=\"proxy\"<\/em>\nclass=\"org.springframework.aop.framework.ProxyFactoryBean\"<\/em>>\n<property name=\"target\"<\/em> ref=\"obj\"<\/em>><\/property>\n<property name=\"interceptorNames\"<\/em>>\n<list>\n<value>adviceExecutor<\/value>\n<\/list>\n<\/property>\n<\/bean>\n<\/beans><\/pre>\n\n\n\n
Here are Spring AOP dependencies for your pom.xml in the case of maven project:<\/p>\n\n\n\n
<parent>\n    <groupId>org.springframework.boot<\/groupId>\n    <artifactId>spring-boot-starter-parent<\/artifactId>\n    <version>2.2.6.RELEASE<version>\n<\/parent>\n  \n<dependencies>\n    <dependency>\n        <groupId>org.springframework.boot<\/groupId>\n        <artifactId>spring-boot-starter-aop<\/artifactId>\n    <\/dependency>\n<\/dependencies><\/pre>\n\n\n\n
Now it is recommended to use Spring AspectJ AOP implementation with the Spring Framework. The old-style Spring 1.2 DTD-based AOP implementation is not so comfortable, because Spring AspectJ AOP provides for developers more control. It is easier to use.<\/p>\n\n\n\n
We can use  Spring AOP AspectJ implementation by one of the two ways. The first way is by annotation. The second way is by XML configuration (schema based).<\/p>\n\n\n\n
Implementation of the AspectJ AOP provides this list of annotations:<\/p>\n\n\n\n
@Aspect is for the declaratio of the class as an aspect.<\/p>\n\n\n\n
@Pointcut is for the creation of the pointcut expression.<\/p>\n\n\n\n
For advices we need to use the annotations given below:<\/p>\n\n\n\n
@Before annotation is for the before advice. It will be executed before calling the actual method.<\/p>\n\n\n\n
@After declares the after advice. It will be executed after calling the actual method and before returning the result.<\/p>\n\n\n\n
@AfterReturning annotation is for after returning advice. It will be executed after calling the actual method and before returning the result. It is important that you can get the result value in this type of the advice.<\/p>\n\n\n\n
@Around annotation is for the around advice. It will be executed before and after calling the actual method.<\/p>\n\n\n\n
@AfterThrowing annotation is used to declare the throws advice. It will be executed if the actual method throws an exception.<\/p>\n\n\n\n
Let’s look at an example with the annotations. We have a Spring boot application:<\/p>\n\n\n\n
package<\/strong> edu.example.aop;\n\nimport<\/strong> org.springframework.context.ApplicationContext;\nimport<\/strong> org.springframework.context.support.ClassPathXmlApplicationContext;\n\npublic<\/strong> class<\/strong> AopApplicationRunner {\n    public<\/strong> static<\/strong> void<\/strong> main(String[] args) {\n        ApplicationContext context =\n                new<\/strong> ClassPathXmlApplicationContext(\"aop-config.xml\");\n        User user = (User) context.getBean(\"user\");\n\n        System.out<\/em><\/strong>.println(user);\n        user.throwSomeMysticException();\n    }\n}\n<\/pre>\n\n\n\n
Configuration file aop-config.xml is here:<\/em><\/strong><\/p>\n\n\n\n
<?xml version=\"1.0\"<\/em> encoding=\"UTF-8\"<\/em>?>\n<beans xmlns=\"http:\/\/www.springframework.org\/schema\/beans\"<\/em>\n       xmlns:xsi=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\"<\/em>\n       xmlns:aop=\"http:\/\/www.springframework.org\/schema\/aop\"<\/em>\n       xsi:schemaLocation=\"http:\/\/www.springframework.org\/schema\/beans<\/em>\n    http:\/\/www.springframework.org\/schema\/beans\/spring-beans-3.0.xsd<\/em>\n    http:\/\/www.springframework.org\/schema\/aop<\/em>\n    http:\/\/www.springframework.org\/schema\/aop\/spring-aop-3.0.xsd \"<\/em>>\n\n    <aop:aspectj-autoproxy\/>\n\n    <!-- Definition for user bean -->\n    <bean id=\"user\"<\/em> class=\"edu.example.aop.User\"<\/em>>\n        <property name=\"name\"<\/em>  value=\"Mary\"<\/em> \/>\n        <property name=\"surname\"<\/em>  value=\"Luck\"<\/em> \/>\n        <property name=\"age\"<\/em>  value=\"35\"<\/em> \/>\n    <\/bean>\n\n    <!-- Definition for logging aspect -->\n    <bean id=\"logging\"<\/em> class=\"edu.example.aop.Logging\"<\/em>\/>\n\n<\/beans><\/pre>\n\n\n\n
There is one class User that we initialize in this configuration file too. Let’s look at this class:<\/p>\n\n\n\n
package<\/strong> edu.example.aop;\n\npublic<\/strong> class<\/strong> User {\n    private<\/strong> String name;\n    private<\/strong> String surname;\n    private<\/strong> Integer age;\n\n    public<\/strong> String getName() {\n        return<\/strong> name;\n    }\n\n    public<\/strong> void<\/strong> setName(String name) {\n        this<\/strong>.name = name;\n    }\n\n    public<\/strong> String getSurname() {\n        return<\/strong> surname;\n    }\n\n    public<\/strong> void<\/strong> setSurname(String surname) {\n        this<\/strong>.surname = surname;\n    }\n\n    public<\/strong> Integer getAge() {\n        return<\/strong> age;\n    }\n\n    public<\/strong> void<\/strong> setAge(Integer age) {\n        this<\/strong>.age = age;\n    }\n\n    public<\/strong> void<\/strong> throwSomeMysticException(){\n        System.out<\/em><\/strong>.println(\"We have some mystic exception here:\");\n        throw<\/strong> new<\/strong> ClassCastException();\n    }\n\n    @Override\n    public<\/strong> String toString() {\n        return<\/strong> \"User:\\n\" +\n                \"Name: \" + name + '\\n' +\n                \"Surname: \" + surname + '\\n' +\n                \"Age: \" + age + \"\\n\";\n    }\n}\n<\/pre>\n\n\n\n
We are going to create aspects for logging:<\/em><\/strong><\/p>\n\n\n\n
package<\/strong> edu.example.aop;\n\nimport<\/strong> org.aspectj.lang.annotation.*;\n\n@Aspect\npublic<\/strong> class<\/strong> Logging {\n\n    @Pointcut(\"execution(* edu.example.aop.*.*(..))\")\n    public<\/strong> void<\/strong> selectAllMethodsAvaliable() {\n\n    }\n\n    @Before(\"selectAllMethodsAvaliable()\")\n    public<\/strong> void<\/strong> beforeAdvice() {\n        System.out<\/em><\/strong>.println(\"Now we are going to initiate user's profile.\");\n    }\n\n    @After(\"selectAllMethodsAvaliable()\")\n    public<\/strong> void<\/strong> afterAdvice() {\n        System.out<\/em><\/strong>.println(\"User's profile has been initiated.\");\n    }\n\n    @AfterReturning(pointcut = \"selectAllMethodsAvaliable()\", returning = \"someValue\")\n    public<\/strong> void<\/strong> afterReturningAdvice(Object someValue) {\n        System.out<\/em><\/strong>.println(\"Value: \" + someValue.toString());\n    }\n\n    @AfterThrowing(pointcut = \"selectAllMethodsAvaliable()\", throwing = \"e\")\n    public<\/strong> void<\/strong> inCaseOfExceptionThrowAdvice(ClassCastException e) {\n        System.out<\/em><\/strong>.println(\"We have an exception here: \" + e.toString());\n    }\n\n}\n<\/pre>\n\n\n\n
The output will be:<\/em><\/strong><\/p>\n\n\n\n
\n
Now we are going to initiate user’s profile.
User’s profile has been initiated.
Value: User:
Name: Mary
Surname: Luck
Age: 35<\/p>\n\n\n\n
User:
Name: Mary
Surname: Luck
Age: 35<\/p>\n<\/blockquote>\n\n\n\n
Now we are going to initiate user’s profile.
We have some mystic exception here:
User’s profile has been initiated.
We have an exception here: java.lang.ClassCastException<\/p>\n\n\n\n
Let’s summarize why AOP is useful. First of all, it is quick code reuse. We can reuse the code of aspects across many classes without touching much of the existing code. We can enhance numerous classes without repeating code, just by using simple annotation.<\/p>\n\n\n\n
Also, it helps to deal with third-party code. For example, we need to inject shared behavior into a function that is using in core components. Unfortunately, we can’t alter the third-party code’s behavior. Even in the case of open-source code we need to understand and adapt it to our needs. The AOP allows us to decorate the needed behavior without touching the third-party code.<\/p>\n\n\n\n
If you apply AOP your code corresponds to the single-responsibility principle. You can use aspects for authentication, logging, tracing, error handling, and the like.
<\/p>\n\n\n\n
Enterprise Architecture Benefits of Spring AOP<\/h2>\n\n\n\n
Clean Separation of Concerns with Spring AOP<\/h3>\n\n\n\n
By isolating cross-cutting responsibilities such as logging, validation, and auditing from core business logic, development teams can maintain a clearer architectural structure. This approach improves code readability, shortens onboarding time for new engineers, and makes long-term maintenance easier because infrastructure-related behavior can evolve independently of functional requirements.<\/p>\n\n\n\n
Observability and Performance with Spring AOP<\/h2>\n\n\n\n
In production environments, centralized monitoring is essential for maintaining system reliability. Using aspects to capture execution times, request traces, and operational metrics enables teams to gain visibility into application behavior without embedding diagnostic logic across multiple layers. This method supports faster root-cause analysis and aligns well with modern DevOps and SRE practices.<\/p>\n\n\n\n
Security Enforcement Using Spring AOP<\/h2>\n\n\n\n
Security policies often need to be applied consistently across services and modules. Defining authentication, authorization, and data-handling rules as reusable aspects ensures that new features automatically comply with organizational standards. This reduces the likelihood of overlooked checks and strengthens overall application resilience against common threats.<\/p>\n\n\n\n
Testing and Maintainability in Spring AOP<\/h2>\n\n\n\n
Because aspects are managed as standard components within the application context, they can be easily enabled, disabled, or mocked during testing. This flexibility allows teams to verify business logic in isolation while still validating cross-cutting behaviors through targeted integration tests, resulting in higher confidence during releases.<\/p>\n\n\n\n
Scaling Enterprise Systems with Spring AOP<\/h2>\n\n\n\n
As applications grow in size and complexity, modular extension points become increasingly valuable. By using aspects to introduce new policies, compliance rules, or operational features, organizations can adapt to changing requirements without extensive refactoring. This supports continuous improvement while preserving system stability and architectural integrity.<\/p>\n\n\n\n
Why Spring AOP Matters in Enterprise Development<\/h2>\n\n\n\n
Spring AOP provides a practical and scalable way to manage cross-cutting concerns such as security, logging, performance monitoring, and compliance without cluttering business logic. By integrating seamlessly with the Spring ecosystem, it helps teams build modular, testable, and maintainable systems that can evolve with changing technical and organizational requirements.<\/p>\n","protected":false},"excerpt":{"rendered":"
Aspect-Oriented Programming is a paradigm that allows adding additional behavior to existing code without its modification. That additional code usually is needed for multiple types and objects. It can be a logic for transaction management, logging, or security. It is calling cross-cutting concerns. Spring framework has its own library to make aspects possible (Spring AOP). […]<\/p>\n","protected":false},"author":1,"featured_media":4082,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[42],"tags":[1126,1080,1124,1125],"class_list":["post-4075","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java-tutorials","tag-aop-advices","tag-spring-aop","tag-terminology","tag-types-of-aop"],"_links":{"self":[{"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/posts\/4075","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/comments?post=4075"}],"version-history":[{"count":1,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/posts\/4075\/revisions"}],"predecessor-version":[{"id":34405,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/posts\/4075\/revisions\/34405"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/media\/4082"}],"wp:attachment":[{"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/media?parent=4075"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/categories?post=4075"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/tags?post=4075"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}