{"id":313,"date":"2025-09-23T13:00:00","date_gmt":"2025-09-23T13:00:00","guid":{"rendered":"https:\/\/springmasteryhub.com\/?p=313"},"modified":"2025-09-17T13:57:23","modified_gmt":"2025-09-17T13:57:23","slug":"a-simple-guide-to-aop-in-spring-boot","status":"publish","type":"post","link":"https:\/\/springmasteryhub.com\/?p=313","title":{"rendered":"A Simple Guide to AOP in Spring Boot"},"content":{"rendered":"\n

What Is<\/strong><\/h2>\n\n\n\n

This annotation is a component of Aspect-Oriented Programming. It will define a class as an aspect in Spring AOP. When using aspects, you can define some behaviors that will happen when certain criteria match the defined configurations of your aspect, such as when a method annotated with some custom annotation is executed or a method from a path is called.<\/p>\n\n\n\n

Why Is Important<\/strong><\/h2>\n\n\n\n

Separate concerns: for example, you can create a logging aspect that will isolate the logging from your business logic<\/p>\n\n\n\n

Reusability: you can reuse the functionalities that you created in your aspect in many places in your application, and keep a unique central point that makes it easier to modify and propagate to all points of your application<\/p>\n\n\n\n

How To Use It<\/strong><\/h2>\n\n\n\n

Dependencies<\/strong><\/h3>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
<<\/span>dependency<\/span>><\/span><\/span>\n    <<\/span>groupId<\/span>>org.springframework.boot<\/<\/span>groupId<\/span>><\/span><\/span>\n    <<\/span>artifactId<\/span>>spring-boot-starter-aop<\/<\/span>artifactId<\/span>><\/span><\/span>\n<\/<\/span>dependency<\/span>><\/span><\/span>\n<\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
Step 1<\/strong><\/h3>\n\n\n\n
You need to enable AOP in a Spring configuration. You can achieve this by using the annotation @EnableAspectJAutoProxy<\/code>:<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
import<\/span> org.springframework.context.annotation.Configuration;<\/span><\/span>\nimport<\/span> org.springframework.context.annotation.EnableAspectJAutoProxy;<\/span><\/span>\n<\/span>\n@<\/span>Configuration<\/span><\/span>\n@<\/span>EnableAspectJAutoProxy<\/span><\/span>\npublic<\/span> <\/span>class<\/span> <\/span>AppConfig<\/span> {<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
Step 2<\/strong><\/h3>\n\n\n\n
Create your aspect handler class<\/p>\n\n\n\n
Create a new class and add the\u00a0@Aspect<\/code>\u00a0annotation to the class level.<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
import<\/span> org.aspectj.lang.annotation.Aspect;<\/span><\/span>\nimport<\/span> org.slf4j.Logger;<\/span><\/span>\nimport<\/span> org.slf4j.LoggerFactory;<\/span><\/span>\nimport<\/span> org.springframework.stereotype.Component;<\/span><\/span>\n<\/span>\n@<\/span>Aspect<\/span><\/span>\n@<\/span>Component<\/span><\/span>\npublic<\/span> <\/span>class<\/span> <\/span>LoggingAspect<\/span> {<\/span><\/span>\n    <\/span>private<\/span> <\/span>static<\/span> <\/span>final<\/span> <\/span>Logger<\/span> logger <\/span>=<\/span> LoggerFactory.<\/span>getLogger<\/span>(LoggingAspect.class);<\/span><\/span>\n    <\/span>\/\/ Add behaviors here<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
Step 3<\/strong><\/h3>\n\n\n\n
Define what behavior is going to happen when the criteria are matched.<\/p>\n\n\n\n
Example<\/strong><\/h2>\n\n\n\n
You want to log every time a method is invoked. So you can create a pointcut before the method is called. Using the @Before<\/code> annotation.<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
import<\/span> org.aspectj.lang.annotation.Aspect;<\/span><\/span>\nimport<\/span> org.aspectj.lang.annotation.Before;<\/span><\/span>\nimport<\/span> org.slf4j.Logger;<\/span><\/span>\nimport<\/span> org.slf4j.LoggerFactory;<\/span><\/span>\nimport<\/span> org.springframework.stereotype.Component;<\/span><\/span>\n<\/span>\n@<\/span>Aspect<\/span><\/span>\n@<\/span>Component<\/span><\/span>\npublic<\/span> <\/span>class<\/span> <\/span>LoggingAspect<\/span> {<\/span><\/span>\n<\/span>\n    <\/span>private<\/span> <\/span>static<\/span> <\/span>final<\/span> <\/span>Logger<\/span> logger <\/span>=<\/span> LoggerFactory.<\/span>getLogger<\/span>(LoggingAspect.class);<\/span><\/span>\n<\/span>\n    @<\/span>Before<\/span>(<\/span>"<\/span>execution(* org.spring.mastery.service.TestService.testBefore(..))<\/span>"<\/span>)<\/span><\/span>\n    <\/span>public<\/span> <\/span>void<\/span> <\/span>logBeforeMethod<\/span>() {<\/span><\/span>\n        logger.<\/span>info<\/span>(<\/span>"<\/span>A method is about to be executed!<\/span>"<\/span>);<\/span><\/span>\n    }<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
The example above will execute before the following method is called:<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
package<\/span> <\/span>org.spring.mastery.service<\/span>;<\/span><\/span>\n<\/span>\nimport<\/span> org.springframework.stereotype.Service;<\/span><\/span>\n<\/span>\n@<\/span>Service<\/span><\/span>\npublic<\/span> <\/span>class<\/span> <\/span>TestService<\/span> {<\/span><\/span>\n<\/span>\n    <\/span>public<\/span> <\/span>String<\/span> <\/span>testBefore<\/span>(<\/span>String<\/span> <\/span>name<\/span>) {<\/span><\/span>\n        <\/span>return<\/span> <\/span>"<\/span>Hello, <\/span>"<\/span> <\/span>+<\/span> name;<\/span><\/span>\n    }<\/span><\/span>\n<\/span>\n}<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
Or if you want it to, you can add a behavior after the method is executed, using @After<\/code><\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
import<\/span> org.aspectj.lang.annotation.After;<\/span><\/span>\n<\/span>\n@<\/span>After<\/span>(<\/span>"<\/span>execution(* org.spring.mastery.service.TestService.testAfter(..))<\/span>"<\/span>)<\/span><\/span>\npublic<\/span> <\/span>void<\/span> <\/span>logAfterMethod<\/span>() {<\/span><\/span>\n    logger.<\/span>info<\/span>(<\/span>"<\/span>A method has just finished (success or error).<\/span>"<\/span>);<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
This will be executed after the following method is executed:<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
package<\/span> <\/span>org.spring.mastery.service<\/span>;<\/span><\/span>\n<\/span>\nimport<\/span> org.springframework.stereotype.Service;<\/span><\/span>\n<\/span>\n@<\/span>Service<\/span><\/span>\npublic<\/span> <\/span>class<\/span> <\/span>TestService<\/span> {<\/span><\/span>\n<\/span>\n    <\/span>public<\/span> <\/span>String<\/span> <\/span>testAfter<\/span>(<\/span>String<\/span> <\/span>name<\/span>) {<\/span><\/span>\n        <\/span>return<\/span> <\/span>"<\/span>Hello, <\/span>"<\/span> <\/span>+<\/span> name;<\/span><\/span>\n    }<\/span><\/span>\n}<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
You can also add an aspect to detect the return of a method, and also catch the result using @AfterReturning<\/code><\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
import<\/span> org.aspectj.lang.annotation.AfterReturning;<\/span><\/span>\n<\/span>\n@<\/span>AfterReturning<\/span>(<\/span>pointcut<\/span> <\/span>=<\/span> <\/span>"<\/span>execution(* org.spring.mastery.service.TestService.testAfterReturning(..))<\/span>"<\/span>, <\/span>returning<\/span> <\/span>=<\/span> <\/span>"<\/span>result<\/span>"<\/span>)<\/span><\/span>\npublic<\/span> <\/span>void<\/span> <\/span>logAfterReturning<\/span>(<\/span>Object<\/span> result) {<\/span><\/span>\n    logger.<\/span>info<\/span>(<\/span>"<\/span>Method returned value: {}<\/span>"<\/span>, result);<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
The event above will be triggered when the following method returns something:<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
package<\/span> <\/span>org.spring.mastery.service<\/span>;<\/span><\/span>\n<\/span>\nimport<\/span> org.springframework.stereotype.Service;<\/span><\/span>\n<\/span>\n@<\/span>Service<\/span><\/span>\npublic<\/span> <\/span>class<\/span> <\/span>TestService<\/span> {<\/span><\/span>\n<\/span>\n    <\/span>public<\/span> <\/span>String<\/span> <\/span>testAfterReturning<\/span>(<\/span>String<\/span> <\/span>name<\/span>) {<\/span><\/span>\n        <\/span>return<\/span> <\/span>"<\/span>Hello, <\/span>"<\/span> <\/span>+<\/span> name;<\/span><\/span>\n    }<\/span><\/span>\n<\/span>\n}<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
You can also detect and do some custom behavior if an exception has been thrown, using @AfterThrowing<\/code><\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
import<\/span> org.aspectj.lang.annotation.AfterThrowing;<\/span><\/span>\n<\/span>\n@<\/span>AfterThrowing<\/span>(<\/span>pointcut<\/span> <\/span>=<\/span> <\/span>"<\/span>execution(* org.spring.mastery.service.TestService.testAfterThrowing(..))<\/span>"<\/span>, <\/span>throwing<\/span> <\/span>=<\/span> <\/span>"<\/span>ex<\/span>"<\/span>)<\/span><\/span>\npublic<\/span> <\/span>void<\/span> <\/span>logAfterThrowing<\/span>(<\/span>Exception<\/span> ex) {<\/span><\/span>\n    logger.<\/span>error<\/span>(<\/span>"<\/span>Method threw exception: {}<\/span>"<\/span>, ex.<\/span>getMessage<\/span>());<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
If the method below throws an exception, the aspect method above will be executed:<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
package<\/span> <\/span>org.spring.mastery.service<\/span>;<\/span><\/span>\n<\/span>\nimport<\/span> org.springframework.stereotype.Service;<\/span><\/span>\n<\/span>\n@<\/span>Service<\/span><\/span>\npublic<\/span> <\/span>class<\/span> <\/span>TestService<\/span> {<\/span><\/span>\n<\/span>\n\t\t <\/span>public<\/span> <\/span>String<\/span> <\/span>testAfterThrowing<\/span>() {<\/span><\/span>\n        <\/span>throw<\/span> <\/span>new<\/span> <\/span>RuntimeException<\/span>(<\/span>"<\/span>This is a test exception<\/span>"<\/span>);<\/span><\/span>\n    }<\/span><\/span>\n<\/span>\n}<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
You can also do something before and after the method execution by using the @Around<\/code> annotation.<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
import<\/span> org.aspectj.lang.ProceedingJoinPoint;<\/span><\/span>\nimport<\/span> org.aspectj.lang.annotation.Around;<\/span><\/span>\n<\/span>\n@<\/span>Around<\/span>(<\/span>"<\/span>execution(* org.spring.mastery.service.TestService.testAround(..))<\/span>"<\/span>)<\/span><\/span>\npublic<\/span> <\/span>Object<\/span> <\/span>logAround<\/span>(<\/span>ProceedingJoinPoint<\/span> joinPoint) throws Throwable {<\/span><\/span>\n    logger.<\/span>info<\/span>(<\/span>"<\/span>[Around] Before: {}<\/span>"<\/span>, joinPoint.<\/span>getSignature<\/span>());<\/span><\/span>\n    <\/span>Object<\/span> result <\/span>=<\/span> joinPoint.<\/span>proceed<\/span>();<\/span><\/span>\n    logger.<\/span>info<\/span>(<\/span>"<\/span>[Around] After: {}<\/span>"<\/span>, joinPoint.<\/span>getSignature<\/span>());<\/span><\/span>\n    <\/span>return<\/span> result;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
The method below will trigger the aspect above, before and after the execution:<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
package<\/span> <\/span>org.spring.mastery.service<\/span>;<\/span><\/span>\n<\/span>\nimport<\/span> org.springframework.stereotype.Service;<\/span><\/span>\n<\/span>\n@<\/span>Service<\/span><\/span>\npublic<\/span> <\/span>class<\/span> <\/span>TestService<\/span> {<\/span><\/span>\n<\/span>\n    <\/span>public<\/span> <\/span>String<\/span> <\/span>testAround<\/span>(<\/span>String<\/span> <\/span>name<\/span>) {<\/span><\/span>\n        <\/span>return<\/span> <\/span>"<\/span>Hello, <\/span>"<\/span> <\/span>+<\/span> name;<\/span><\/span>\n    }<\/span><\/span>\n<\/span>\n}<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
But if you don\u2019t want to use the classpath to configure your aspects, you can create a custom annotation and use it in your code, which will make your aspect event reusable as well. You can add a custom annotation like this:<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
import<\/span> java.lang.annotation.<\/span>*<\/span>;<\/span><\/span>\n<\/span>\n@<\/span>Target<\/span>(ElementType.METHOD)<\/span><\/span>\n@<\/span>Retention<\/span>(RetentionPolicy.RUNTIME)<\/span><\/span>\npublic<\/span> @<\/span>interface<\/span> <\/span>Auditable<\/span> {<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
And then configure your aspect to read your custom annotation:<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
import<\/span> org.aspectj.lang.annotation.Before;<\/span><\/span>\n<\/span>\n@<\/span>Before<\/span>(<\/span>"<\/span>@annotation(com.example.aop.Auditable)<\/span>"<\/span>)<\/span><\/span>\npublic<\/span> <\/span>void<\/span> <\/span>audit<\/span>() {<\/span><\/span>\n    logger.<\/span>info<\/span>(<\/span>"<\/span>Auditing action\u2026<\/span>"<\/span>);<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
Now you can reuse your custom annotation in any method you want, like this:<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
package<\/span> <\/span>org.spring.mastery.service<\/span>;<\/span><\/span>\n<\/span>\nimport<\/span> org.slf4j.Logger;<\/span><\/span>\nimport<\/span> org.slf4j.LoggerFactory;<\/span><\/span>\nimport<\/span> org.spring.mastery.annotation.Auditable;<\/span><\/span>\nimport<\/span> org.springframework.stereotype.Service;<\/span><\/span>\n<\/span>\n@<\/span>Service<\/span><\/span>\npublic<\/span> <\/span>class<\/span> <\/span>TestService<\/span> {<\/span><\/span>\n<\/span>\n    <\/span>private<\/span> <\/span>static<\/span> <\/span>final<\/span> <\/span>Logger<\/span> logger <\/span>=<\/span> LoggerFactory.<\/span>getLogger<\/span>(TestService.class);<\/span><\/span>\n<\/span>\n    @<\/span>Auditable<\/span><\/span>\n    <\/span>public<\/span> <\/span>void<\/span> <\/span>auditableMethod<\/span>() {<\/span><\/span>\n        logger.<\/span>info<\/span>(<\/span>"<\/span>Executing auditable method<\/span>"<\/span>);<\/span><\/span>\n    }<\/span><\/span>\n}<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
Conclusion<\/strong><\/h2>\n\n\n\n
Aspects are a powerful tool to use with Spring; they help you add behaviors to your code without interfering with your business logic. But be careful using this. One change in the package’s name can break your stuff, and make sure to maintain a good structure that will be easy to find where the behavior comes from.<\/p>\n","protected":false},"excerpt":{"rendered":"
What Is This annotation is a component of Aspect-Oriented Programming. It will define a class as an aspect in Spring AOP. When using aspects, you can define some behaviors that will happen when certain criteria match the defined configurations of your aspect, such as when a method annotated with some custom annotation is executed or a method […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[3,6],"tags":[13,18,20,22,23],"class_list":["post-313","post","type-post","status-publish","format-standard","hentry","category-java","category-spring","tag-java","tag-programming","tag-software-development","tag-spring-boot","tag-spring-framework"],"jetpack_sharing_enabled":true,"jetpack_featured_media_url":"","_links":{"self":[{"href":"https:\/\/springmasteryhub.com\/index.php?rest_route=\/wp\/v2\/posts\/313","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/springmasteryhub.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/springmasteryhub.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/springmasteryhub.com\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/springmasteryhub.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=313"}],"version-history":[{"count":1,"href":"https:\/\/springmasteryhub.com\/index.php?rest_route=\/wp\/v2\/posts\/313\/revisions"}],"predecessor-version":[{"id":314,"href":"https:\/\/springmasteryhub.com\/index.php?rest_route=\/wp\/v2\/posts\/313\/revisions\/314"}],"wp:attachment":[{"href":"https:\/\/springmasteryhub.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=313"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/springmasteryhub.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=313"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/springmasteryhub.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=313"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}