DEV Community: Willian Ferreira Moya

A Simple Guide to AOP in Spring Boot

Willian Ferreira Moya — Tue, 23 Sep 2025 16:00:00 +0000

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 from a path is called.

Why Is Important

Separate concerns: for example, you can create a logging aspect that will isolate the logging from your business logic

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

How To Use It

Dependencies

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

Step 1

You need to enable AOP in a Spring configuration. You can achieve this by using the annotation @EnableAspectJAutoProxy:

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {
}

Step 2

Create your aspect handler class

Create a new class and add the @Aspect annotation to the class-level.

import org.aspectj.lang.annotation.Aspect;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {
    private static final Logger logger = LoggerFactory.getLogger(LoggingAspect.class);
    // Add behaviors here
}

Step 3

Define what behavior is going to happen when the criteria are matched.

Example

You want to log every time a method is invoked. So you can create a pointcut before the method is called. Using the @Before annotation.

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {

    private static final Logger logger = LoggerFactory.getLogger(LoggingAspect.class);

    @Before("execution(* org.spring.mastery.service.TestService.testBefore(..))")
    public void logBeforeMethod() {
        logger.info("A method is about to be executed!");
    }
}

The example above will execute before the following method is called:

package org.spring.mastery.service;

import org.springframework.stereotype.Service;

@Service
public class TestService {

    public String testBefore(String name) {
        return "Hello, " + name;
    }

}

Or if you want it to, you can add a behavior after the method is executed, using @After

import org.aspectj.lang.annotation.After;

@After("execution(* org.spring.mastery.service.TestService.testAfter(..))")
public void logAfterMethod() {
    logger.info("A method has just finished (success or error).");
}

This will be executed after the following method is executed:

package org.spring.mastery.service;

import org.springframework.stereotype.Service;

@Service
public class TestService {

    public String testAfter(String name) {
        return "Hello, " + name;
    }
}

You can also add an aspect to detect the return of a method, and also catch the result using @AfterReturning

import org.aspectj.lang.annotation.AfterReturning;

@AfterReturning(pointcut = "execution(* org.spring.mastery.service.TestService.testAfterReturning(..))", returning = "result")
public void logAfterReturning(Object result) {
    logger.info("Method returned value: {}", result);
}

The event above will be triggered when the following method returns something:

package org.spring.mastery.service;

import org.springframework.stereotype.Service;

@Service
public class TestService {

    public String testAfterReturning(String name) {
        return "Hello, " + name;
    }

}

You can also detect and do some custom behavior if an exception has been thrown using @AfterThrowing

import org.aspectj.lang.annotation.AfterThrowing;

@AfterThrowing(pointcut = "execution(* org.spring.mastery.service.TestService.testAfterThrowing(..))", throwing = "ex")
public void logAfterThrowing(Exception ex) {
    logger.error("Method threw exception: {}", ex.getMessage());
}

If the method below throws an exception, the aspect method above will be executed:

package org.spring.mastery.service;

import org.springframework.stereotype.Service;

@Service
public class TestService {

         public String testAfterThrowing() {
        throw new RuntimeException("This is a test exception");
    }

}

You can also do something before and after the method execution by using the @Around annotation.

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;

@Around("execution(* org.spring.mastery.service.TestService.testAround(..))")
public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
    logger.info("[Around] Before: {}", joinPoint.getSignature());
    Object result = joinPoint.proceed();
    logger.info("[Around] After: {}", joinPoint.getSignature());
    return result;
}

The method below will trigger the aspect above, before and after the execution:

package org.spring.mastery.service;

import org.springframework.stereotype.Service;

@Service
public class TestService {

    public String testAround(String name) {
        return "Hello, " + name;
    }

}

But if you don’t 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:

import java.lang.annotation.*;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Auditable {
}

And then configure your aspect to read your custom annotation:

import org.aspectj.lang.annotation.Before;

@Before("@annotation(com.example.aop.Auditable)")
public void audit() {
    logger.info("Auditing action…");
}

Now you can reuse your custom annotation in any method you want, like this:

package org.spring.mastery.service;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.spring.mastery.annotation.Auditable;
import org.springframework.stereotype.Service;

@Service
public class TestService {

    private static final Logger logger = LoggerFactory.getLogger(TestService.class);

    @Auditable
    public void auditableMethod() {
        logger.info("Executing auditable method");
    }
}

Conclusion

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.

Understanding @Repository in Spring

Willian Ferreira Moya — Tue, 16 Sep 2025 16:00:00 +0000

What is `@Repository`?

This is a class-level annotation that indicates that the Class's purpose is to store, search, retrieve, update, and delete objects. It has a special role when dealing with databases.

Why is it important?

Legibility: This annotation separates the communication with the database in a separate layer.
Simplifies database communication: You can define an interface that extends JpaRepository, CrudRepository, or PagingAndSortingRepository and save some time when implementing basic interactions with the database.
Translate exceptions: It will convert database exceptions into Spring's DataAccessException hierarchy, converting the JPA exceptions into a more consistent exception model that Spring provides.

How to use `@Repository`

Define an interface, annotate with @Repository, and extend one of those interfaces:

JpaRepository, CrudRepository, or PagingAndSortingRepository.

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
}

This will already set you up with some basic main operations. If you need, you can add some custom methods like this:

import java.util.Optional;

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByUsername(String username);
    List<User> findAllByActiveTrue();
}

Bellow you have more examples using the other interfaces that I’ve mentioned

JpaRepository

package org.spring.mastery.repository;

import org.spring.mastery.model.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import java.util.List;
import java.util.Optional;

@Repository
public interface UserJpaRepository extends JpaRepository<User, Long> {
    Optional<User> findByUsername(String username);
    List<User> findAllByActiveTrue();
}

CrudRepository

package org.spring.mastery.repository;

import org.spring.mastery.model.User;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;

import java.util.List;
import java.util.Optional;

@Repository
public interface UserCrudRepository extends CrudRepository<User, Long> {
    Optional<User> findByUsername(String username);
    List<User> findAllByActiveTrue();
}

Dependencies

To use Spring Data JPA and H2, you need to add the following dependencies to your pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

Conclusion

By using @Repository, you can utilize the advantages and facilities that Spring offers when working with databases. You’ll be set up fast to deliver value with your application, avoiding the boilerplate necessary to communicate with a database.

What is @Service In Spring?

Willian Ferreira Moya — Wed, 10 Sep 2025 16:00:00 +0000

This is a class-level annotation that is a specialization of @Component designed to handle business logic. It will turn your class into a Spring-managed bean.

Why is it important?

By using this annotation, you are implementing a separation of concerns by placing the business logic in a specific layer, thereby improving code readability.

How to use it?

First, define a class annotated with @Service that has some business logic in the methods:

package com.example.demo.service;

import org.springframework.stereotype.Service;

@Service
public class UserService {

    public String getWelcomeMessage(String username) {
        return "Welcome, " + username + "!";
    }
}

Then inject your created service where it’s needed:

package com.example.demo.controller;

import com.example.demo.service.UserService;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/users")
public class UserController {

    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{username}")
    public String welcomeUser(@PathVariable String username) {
        return userService.getWelcomeMessage(username);
    }
}

Let’s test it

Let’s call our endpoint

curl http://localhost:8080/users/SpringMastery

The result should look like this:

Welcome, SpringMastery!

Conclusion

That’s it, it's that easy to create a service in your application. Now you know how, when to use, and how important this annotation is in your Spring applications.

Have you ever thought about the difference between @Service and @Component?

Understanding @RestController in Spring Boot

Willian Ferreira Moya — Tue, 17 Jun 2025 16:00:00 +0000

What is it?

This annotation is a specialization of @Controller, specifically designed for creating REST endpoints.

It combines the @Controller and @ResponseBody annotations, making it easier to create RESTful applications.

If your application works with RESTful APIs, this is the go-to annotation to define your controllers.
It simplifies your code and communicates the intent: this class serves REST endpoints.

How to use it?

Create a class and annotate it with @RestController:

import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyController {
}

Define a method to respond to an HTTP method:

import org.springframework.web.bind.annotation.GetMapping;

@RestController
public class MyController {

    @GetMapping("/hello")
    public MessageResponse hello() {
        return new MessageResponse("Hello, world!");
    }
}

Create the response record:

public record MessageResponse(String message) {}

And that’s it! Now you have a controller and method that will respond to an endpoint for a particular HTTP method in a REST-compatible format.

Let’s test it out:

curl http://localhost:8080/hello

The response should look like this:

{
  "message": "Hello, world!"
}

Conclusion

By using this annotation, Spring simplifies the creation of RESTful applications.

Now that you know the difference between @Controller and @RestController, you can make sure to choose the better option for your context.

How to Use @PropertySource in Your Spring Application

Willian Ferreira Moya — Thu, 05 Jun 2025 16:00:00 +0000

What is the `@PropertySource` annotation?

The @PropertySource annotation is used to tell Spring to load a specific properties file from a location provided in the annotation. It is used in conjunction with @Configuration at the class level. It allows you, as a developer, to externalize the configuration of your application.

Why use `@PropertySource`?

It allows you to load properties files from any location.
In Java 8+, you can repeat this annotation many times, allowing you to load multiple configuration files.
It supports the usage of placeholders using Spring Expression Language syntax.
You can handle missing files by ignoring them if they are not found.
Property override: if you have many properties with the same name, the last definition will override the first one.

How to use `@PropertySource`

The first example is the default way, by configuring with @Configuration and pointing to a path:

@Configuration
@PropertySource("classpath:application.properties")
public class AppConfig {

    private static final Logger logger = getLogger(AppConfig.class);
    @Value("${property.name}")
    private String propertyName;

    @PostConstruct
    public void init() {
        logger.info("Property loaded: property.name={}", propertyName);
    }
    // getters and setters
}

Here’s the configuration file:

property.name=property value

If you run the example above the init() will show the value of the property in the console:

INFO 17840 --- [           main] org.spring.mastery.config.AppConfig      : Property loaded: property.name=property value

You can define as many @PropertySource annotations as you want:

@Configuration
@PropertySource("classpath:application.properties")
@PropertySource("classpath:another.properties")
public class AppConfig {

    private static final Logger logger = getLogger(AppConfig.class);
    @Value("${property.name}")
    private String propertyName;

    @Value("${another.property}")
    private String anotherProperty;

    @PostConstruct
    public void init() {
        logger.info("Property loaded: property.name={}", propertyName);
        logger.info("Property loaded: property.name={}", anotherProperty);
    }
    // getters and setters
}

The console will have these lines:

INFO 28208 --- [           main] org.spring.mastery.config.AppConfig      : Property loaded: property.name=property value
INFO 28208 --- [           main] org.spring.mastery.config.AppConfig      : Property loaded: property.name=another valu

You can use @PropertySources to group them if you want:

@Configuration
@PropertySources({
    @PropertySource("classpath:application.properties"),
    @PropertySource("classpath:another.properties")
})
public class AppConfig {
    @Value("${property.name}")
    private String propertyName;

    @Value("${another.property}")
    private String anotherProperty;

    // getters and setters
}

It’ll work like the previous example:

INFO 28316 --- [           main] org.spring.mastery.config.AppConfig      : Property loaded: property.name=property value
INFO 28316 --- [           main] org.spring.mastery.config.AppConfig      : Property loaded: property.name=another value

You can use a placeholder using Spring Expression Language to make things more flexible by using one property to define a path location to another property file. You can use this in scenarios where you can add a .properties file that will be placed outside your project (in this example is still in the class path, but you can put it where you want in the file system. This is useful in production systems where you want to hide the properties that will be used in the production server from the source code.

@Configuration
@PropertySource("classpath:${config.location}/external.properties")
public class AppConfig {

    private static final Logger logger = getLogger(AppConfig.class);
    @Value("${external.property.name}")
    private String propertyName;

    @PostConstruct
    public void init() {
        logger.info("Property loaded: property.name={}", propertyName);
    }
    // getters and setters
}

The application.properties will look like this:

property.name=property value
config.location=external

And the external.properties will look like this:

external.property.name=external value

PS: The external name is optional; you can add the name you want.

You can also ignore the property loading if the file is not found:

@Configuration
@PropertySource(value = "classpath:optional.properties", ignoreResourceNotFound = true)
public class AppConfig {

    private static final Logger logger = getLogger(AppConfig.class);
    @Value("${optional.property:default}")
    private String optionalProperty;

    @PostConstruct
    public void init() {
        logger.info("Property loaded: property.name={}", optionalProperty);
    }
    // getters and setters
}

If the optional.properties does not exist, the default value will be set:

INFO 8912 --- [           main] org.spring.mastery.config.AppConfig      : Property loaded: property.name=default

If it exists, it will show the property value defined on the existing optional.properites

INFO 29992 --- [           main] org.spring.mastery.config.AppConfig      : Property loaded: property.name=optional value

In this post, we learned different ways on how to use the @PropertySource in your project. Have you seen another way to use it? Did this annotation help you solve a problem in your project?

If you like this topic, make sure to follow me. In the following days, I’ll be explaining more about Spring annotations! Stay tuned!

Willian Moya (@WillianFMoya) / X (twitter.com)

Willian Ferreira Moya | LinkedIn

How to Use @Controller in Spring

Willian Ferreira Moya — Tue, 03 Jun 2025 16:00:00 +0000

What is?

This is a class-level annotation that tells Spring that your class is a controller. A controller is an entry point for a web application. This allows you to define a path to communicate with your backend using REST methods or by serving and responding html forms.

This annotation is more general and allows your controller to serve REST endpoints and serve webpage content, which is very common in the MVC pattern.

Why is this important

This annotation is what allows your front end to communicate with the backend, allowing you to define routes, pages, dynamic content, etc. If you are working with web applications, this annotation is one of the most important ones.

How to use @Controller

Defining a controller class

import org.springframework.stereotype.Controller;

@Controller
public class MyController {
    // controller methods go here
}

Defining an endpoint and its respective HTTP method

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class MyController {
    @GetMapping("/greeting")
    public String greeting() {
        return "greeting";  // resolves to a view named "greeting"
    }
}

Add a page in the location src/main/resources/templates/greeting.html with the same name as the string returned by the controller to return an HTML page from the server

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8" />
    <title>Greeting</title>
</head>
<body>
<h1>Hello!</h1>
</body>
</html>

Testing

Testing @Controller without REST

Using curl to call our controller

curl -i http://localhost:8080/greeting

The result should look like this*:*

HTTP/1.1 200 
Content-Type: text/html;charset=UTF-8
Content-Language: pt-BR
Transfer-Encoding: chunked

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8" />
    <title>Greeting</title>
</head>
<body>
<h1>Hello!</h1>
</body>
</html>

Creating a REST endpoint with @ResponseBody

import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class RestControllerExample {
    @GetMapping("/api/message")
    @ResponseBody
    public ResponseEntity<String> getMessage() {
        return ResponseEntity.ok("Hello, World!");
    }
}

Testing @Controller with @ResponseBody

When calling with curl :


curl -i http://localhost:8080/api/message

It should return like this:

HTTP/1.1 200 
Content-Type: text/plain;charset=UTF-8
Content-Length: 13

Hello, World!

Conclusion

This is one of the most important and common annotations when it comes to creating web applications with Spring. The usage is straightforward, making it easier to add new controllers and endpoints to your application.

Willian Moya (@WillianFMoya) / X

Willian Ferreira Moya | LinkedIn

Understanding the @Configuration Annotation in Spring

Willian Ferreira Moya — Tue, 27 May 2025 16:00:00 +0000

The @Configuration annotation indicates to Spring that the class has one or more @Bean methods. When starting the application context, Spring will look to these classes to load the Spring IoC container with the beans you define in those methods.

It allows you to create custom beans and perform configurations (like when you use Spring Security) so that everything is ready to go when the application starts.

It's a really simple and powerful annotation and is often combined with other annotations.

Let's see it in practice.

@Configuration is a class-level annotation. So we can define a configuration class and create some bean methods like this:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyConfiguration {

    private static final Logger log = LoggerFactory.getLogger(MyConfiguration.class);

    @Bean
    public MyBean myBean() {
        log.info("Creating my custom bean");
        return new MyBean();
    }
}

class MyBean {
    // bean properties and methods
}

@SpringBootApplication
public class Main {

    public static void main(String[] args) {
        SpringApplication.run(Main.class, args);
    }
}

Spring will load your configurations by default if they’re in the same package as your application’s main. Or if it’s in the configurations, it's in sub-packages from your application’s main.

For example:

If your main is in org.example.application and your configurations are located in packages in the same package tree, for example, org.example.application.config, Spring will automatically scan and read these configurations for you.

But if it is not reading your configuration class because they are not in the same package tree, you could use the @Import annotation in your application or use the @ComponentScan annotation to point to Spring where those configurations are.

Now you know how to configure your Spring applications using the @Configuration annotation.

If you like this topic, make sure to follow me. In the following days, I’ll be explaining more about Spring annotations! Stay tuned!

Willian Moya (@WillianFMoya) / X (twitter.com)

Willian Ferreira Moya | LinkedIn

Understanding the @Scope Annotation in Spring: How Bean Scopes Work

Willian Ferreira Moya — Tue, 13 May 2025 16:00:00 +0000

What is `@Scope`

This is a class-level annotation that allows the developer to define the scope of a Spring bean. By default, all Spring beans are singletons, but by using this annotation, you can modify that to the following scopes:

singleton: the default one, where Spring will create a single instance and share it throughout the application wherever the bean is needed.
Prototype: This scope creates a new instance whenever the bean is requested.
Request: Spring will create an instance of the bean that will live until the HTTP request is done.
session: Spring will create a bean specific for that session; for each session, it will be a new bean.

Why is it important:

Resource management: This annotation will give you the flexibility you need to manage the resources of your application and help you have more control over your application beans.
Concurrency: Sometimes, you can have a problem with concurrency using a bean that is a singleton, especially in cases where your bean handles some state. So to avoid concurrency problems, it is wise to change the bean scope to one that better suits your case.

How to use `@Scope`

In every bean that you have, you can combine the bean definition with the @Scope definition.

Defining a service with `@Scope` in singleton mode

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Service;

@Service
@Scope(ConfigurableBeanFactory.SCOPE_SINGLETON) // This is the default, but shown here for clarity
public class SingletonService {
    private static final Logger logger = LoggerFactory.getLogger(SingletonService.class);

    public SingletonService() {
        logger.info("SingletonService instance created");
    }

    public void doWork() {
        logger.info("Doing work in singleton service");
    }
}

Let’s test it out. The code below will get the bean after the application starts, and call the doWork function so we can check the scope behavior:

@Component
public class SingletonTest {

    @Autowired
    private ApplicationContext context;

    @PostConstruct
    public void usePrototype() {
        SingletonService service1 = context.getBean(SingletonService.class);
        SingletonService service2 = context.getBean(SingletonService.class);
        service1.doWork();
        service2.doWork();
    }
}

We should see only one creation log because it’s a singleton, and the other two logs about the execution of the method doWork should look like this:

INFO 11252 --- [           main] o.spring.mastery.scope.SingletonService  : SingletonService instance created
INFO 11252 --- [           main] o.spring.mastery.scope.SingletonService  : Doing work in singleton service
INFO 11252 --- [           main] o.spring.mastery.scope.SingletonService  : Doing work in singleton service

Defining a bean with scope set to prototype

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Service;

@Service
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public class PrototypeService {
    private static final Logger logger = LoggerFactory.getLogger(PrototypeService.class);

    public PrototypeService() {
        logger.info("PrototypeService instance created");
    }

    public void doWork() {
        logger.info("Doing work in prototype service");
    }
}

Let’s make a test to see how this bean behaves:

import jakarta.annotation.PostConstruct;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;

@Component
public class PrototypeTest {

    @Autowired
    private ApplicationContext context;

    @PostConstruct
    public void usePrototype() {
        PrototypeService service1 = context.getBean(PrototypeService.class);
        PrototypeService service2 = context.getBean(PrototypeService.class);
        service1.doWork();
        service2.doWork();
    }
}

As we explained, the prototype scope will create a new instance whenever the bean is requested. In the code above, we request 2 times before calling the doWork method, so the log lines should be two creation logs followed by two doWork logs. Like this:

INFO 23872 --- [           main] o.spring.mastery.scope.PrototypeService  : PrototypeService instance created
INFO 23872 --- [           main] o.spring.mastery.scope.PrototypeService  : PrototypeService instance created
INFO 23872 --- [           main] o.spring.mastery.scope.PrototypeService  : Doing work in prototype service
INFO 23872 --- [           main] o.spring.mastery.scope.PrototypeService  : Doing work in prototype service

Using a proxy and a custom scope (request-scoped example)

In this example, we will see how the request scope works in practice. First, we create a bean with request scope:

import org.springframework.context.annotation.Scope;
import org.springframework.context.annotation.ScopedProxyMode;
import org.springframework.stereotype.Service;
import org.springframework.web.context.WebApplicationContext;

@Service
@Scope(value = WebApplicationContext.SCOPE_REQUEST, proxyMode = ScopedProxyMode.TARGET_CLASS)
public class RequestScopedService {

    public RequestScopedService() {
        System.out.println("RequestScopedService instance created");
    }

    public void handleRequest() {
        System.out.println("Handling request in request scoped service");
    }
}

Then we use this bin in a controller

@RestController
@RequestMapping("/api")
public class SampleController {

    ****@Autowired
    private RequestScopedService requestScopedService;

    @GetMapping("/test")
    public ResponseEntity<String> test() {
        requestScopedService.handleRequest();
        return ResponseEntity.ok("Request handled");
    }
}

If you start the application, you will see that there won’t be any logs saying RequestScopedService instance created. This bean will only be created in an HTTP request scope. So if we call the controller with:

curl 'http://localhost:8080/api/test' -Method Get

Now you will see the logs of the bean being created:

INFO 10704 --- [nio-8080-exec-2] o.s.mastery.scope.RequestScopedService   : RequestScopedService instance created
INFO 10704 --- [nio-8080-exec-2] o.s.mastery.scope.RequestScopedService   : Handling request in request scoped service

Conclusion

This is a powerful annotation that allows you to modify the default bean creation behavior from Spring. This can be useful to have in your tool belt, especially when debugging concurrency problems, believe me, it happens.

If you found this topic interesting, follow me for more insights into Spring annotations and other valuable tips!

Willian Moya (@WillianFMoya) / X (twitter.com)

Willian Ferreira Moya | LinkedIn

Spring Essentials: How to Use the @Bean Annotation for Custom Services

Willian Ferreira Moya — Tue, 29 Apr 2025 16:00:00 +0000

In our application, we have a lot of objects. These objects are components of our application. When we want Spring to create, manage, and inject these objects, they are considered Spring beans.

The @Bean annotation is a method-level annotation that we can use to tell Spring that we want it to manage the instance for us.

When starting the application context, Spring will look for these @Bean methods and add them to the IoC container to manage their lifecycle so that other components can inject and use them.

This annotation is usually placed in configuration classes. As we know, Spring already has some auto-configuration for resources like Spring Kafka, Spring Cache, etc.

But if you want to create and manage a custom resource, like a custom notification service, using the @Bean to make this custom bean available in your application is the way to go.

In some cases, we can use the @Bean annotation to customize some auto-configured beans. This allows us to replace the default configuration with a modified version that suits our needs.

Let's take a look.

Creating a Custom Bean

In this scenario, our application must use a custom SMTP service to send emails. We can create a method to instantiate the service as we need and return the object. Since we want this to become a bean, we annotate the method with @Bean to tell Spring to put this object in the Spring IoC as a bean.

package org.spring.mastery.config;

import org.spring.mastery.service.SmtpNotificationService;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class NotificationConfig {

    @Bean
    public SmtpNotificationService smtpNotificationService() {
        return new SmtpNotificationService("smtp.example.com", 587, "username", "password");
    }
}

The class we want to be a custom bean:

package org.spring.mastery.service;

public class SmtpNotificationService {

    public SmtpNotificationService(String host, int port, String username, String password) {
        //add fake behavior
        System.out.println(STR."Connecting to SMTP server at \{host}:\{port}");
        System.out.println(STR."Authenticating with username: \{username}");
        System.out.println("Sending a test email to verify connection...");
        System.out.println("Email sent successfully. Connection verified.");
    }

    public void sendEmail(String mail, String subject, String message) {
        System.out.println(STR."Sending email to \{mail}...");
        System.out.println(STR."Email subject: \{subject}");
        System.out.println(STR."Email message: \{message}");
        System.out.println("Email sent successfully.");

    }
}

Using the Custom Bean

Now we can inject and use the custom bean that we created.

package com.example.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class NotificationService {

    private final SmtpNotificationService smtpNotificationService;

    @Autowired
    public NotificationService(SmtpNotificationService smtpNotificationService) {
        this.smtpNotificationService = smtpNotificationService;
    }

    public void sendNotification(String message) {
        smtpNotificationService.sendEmail("recipient@example.com", "Subject", message);
    }
}

If we run the project, we should see that spring created the bean for us and the setup of the bean should appear on the console like this:

2025-04-11T10:04:25.296-03:00  INFO 11240 --- [           main] j.LocalContainerEntityManagerFactoryBean : Initialized JPA EntityManagerFactory for persistence unit 'default'
Connecting to SMTP server at smtp.example.com:587
Authenticating with username: username
Sending a test email to verify connection...
Email sent successfully. Connection verified.

Modifying a Bean

Some spring libraries can provide ready-to-use beans for you to use. Like the spring Kafka. You only need to add the dependencies and the respective configuration properties, and you are good to go.

<dependency>
    <groupId>org.springframework.kafka</groupId>
    <artifactId>spring-kafka</artifactId>
    <version>3.3.4</version>
</dependency>

# Kafka Configuration
spring.kafka.bootstrap-servers=localhost:9092
spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer
spring.kafka.producer.value-serializer=org.springframework.kafka.support.serializer.JsonSerializer

package org.spring.mastery.service;

import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Service;

@Service
public class KafkaService {

    private final KafkaTemplate<String, String> kafkaTemplate;

    public KafkaService(KafkaTemplate<String, String> kafkaTemplate) {
        this.kafkaTemplate = kafkaTemplate;
    }

    public void sendMessage(String topic, String message) {
        kafkaTemplate.send(topic, message);
    }
}

But if we want to customize it, we can use the @Bean to create a more customized bean to suit our application needs.

package org.spring.mastery.config;

import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.core.DefaultKafkaProducerFactory;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.core.ProducerFactory;
import org.springframework.kafka.support.serializer.JsonSerializer;

import java.util.HashMap;
import java.util.Map;

@Configuration
public class KafkaConfig {

    @Bean
    public ProducerFactory<String, String> producerFactory() {
        Map<String, Object> configProps = new HashMap<>();
        configProps.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        configProps.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        configProps.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, JsonSerializer.class);
        return new DefaultKafkaProducerFactory<>(configProps);
    }

    @Bean
    public KafkaTemplate<String, String> kafkaTemplate() {
        System.out.println("Create custom kafka bean");
        return new KafkaTemplate<>(producerFactory());
    }
}

The console will show that our bean was created:

2025-04-11T11:06:23.541-03:00  INFO 22032 --- [           main] j.LocalContainerEntityManagerFactoryBean : Initialized JPA EntityManagerFactory for persistence unit 'default'
Create custom kafka bean

Now you have learned how to use the @Bean annotation to tell Spring to handle your custom beans.

Explore this configuration and share your thoughts in the comments or on social media.

If you like this topic, make sure to follow me. In the following days, I’ll be explaining more about Spring annotations! Stay tuned!

Willian Moya (@WillianFMoya) / X (twitter.com)

Willian Ferreira Moya | LinkedIn

Spring Framework Essentials: Understanding @ComponentScan

Willian Ferreira Moya — Tue, 22 Apr 2025 16:00:00 +0000

@ComponentScan is an annotation that tells Spring where to find classes annotated as Spring beans. Using this annotation, we can instruct Spring to create beans only for the specified location. Spring will use the package provided in the annotation to look for beans to create.

If no package is defined in the annotation, Spring will scan recursively from the class where this annotation is declared.

You can also use this annotation to scan multiple packages and configure exclusions to avoid creating certain beans.

If this annotation is not specified, Spring will scan all the classes and jars present on the classpath.

Let’s take a look at a code example.

In this example, we are creating a component scan without a parameter, so Spring will scan from this package and all the subpackages from this declaration.

package org.spring.mastery.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan
public class AppConfig {
}

package org.spring.mastery.service;

import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;

@Service
public class MyService {

    @PostConstruct
    public void init() {
        System.out.println("MyService initialized");
    }
}

package org.spring.mastery.repository;

import org.springframework.stereotype.Repository;

import javax.annotation.PostConstruct;

@Repository
public class MyRepository {

    @PostConstruct
    public void init() {
        System.out.println("MyRepository initialized");
    }
}

package org.spring.another;

import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;

@Service
public class ExcludedService {

    @PostConstruct
    public void init() {
        System.out.println("ExcludedService initialized");
    }
}

In this setup, MyService and MyRepository will be created as beans because they are in sub-packages of org.spring.mastery. However, ExcludedService will not be loaded because it is outside the package hierarchy.

This is the log line:

2025-04-10T11:09:56.876-03:00  INFO 19296 --- [           main] j.LocalContainerEntityManagerFactoryBean : Initialized JPA EntityManagerFactory for persistence unit 'default'
MyRepository initialized
MyService initialized

We can also scan specific packages. Remember, we can use multiple packages in the @ComponentScan annotation.

package org.spring.mastery.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(basePackages = {"org.spring.mastery.service", "org.spring.mastery.repository" })
public class AppConfig {
}

In this example, we are scanning org.spring.mastery.service and org.spring.mastery.repository. Any beans in these packages will be created, while ExcludedService will still not be loaded.

The logs look like this:

2025-04-10T11:14:26.887-03:00  INFO 17868 --- [           main] j.LocalContainerEntityManagerFactoryBean : Initialized JPA EntityManagerFactory for persistence unit 'default'
MyRepository initialized
MyService initialized

If we want to add components outside the org.spring.mastery structure, we can specify it in the @ComponentScan annotation like this:

package org.spring.mastery.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(basePackages = {"org.spring.mastery.service", "org.spring.mastery.repository", "org.spring.another" })
public class AppConfig {
}

Now, the components from the other subpackages will also be loaded:

2025-04-10T11:15:49.313-03:00  INFO 3080 --- [           main] j.LocalContainerEntityManagerFactoryBean : Initialized JPA EntityManagerFactory for persistence unit 'default'
MyRepository initialized
MyService initialized
ExcludedService initialized

If we do not want to load some specific beans or packages, we can create exclusions like this:

package org.spring.mastery.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.stereotype.Service;

@Configuration
@ComponentScan(
    basePackages = {"org.spring.mastery.service", "org.spring.mastery.repository"},
    excludeFilters = @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = Service.class))
public class AppConfig {
}

In this configuration, we are excluding any classes annotated with @Service within the specified packages.

The result log will be:

2025-04-10T14:59:53.710-03:00  INFO 21828 --- [           main] j.LocalContainerEntityManagerFactoryBean : Initialized JPA EntityManagerFactory for persistence unit 'default'
MyRepository initialized
MyService initialized

Now you have learned how @ComponentScan works. Remember, if not set, Spring will scan all classes and jars in your classpath. Have you ever forgotten to add the package to scan and wondered why Spring is not recognizing your new bean (believe me, it happens)?

Explore this configuration and share your thoughts in the comments or on social media.

If you like this topic, make sure to follow me. In the following days, I’ll be explaining more about Spring annotations! Stay tuned!

Willian Moya (@WillianFMoya) / X (twitter.com)

Willian Ferreira Moya | LinkedIn

How to Use Spring's @Profile Annotation for Flexible Configurations

Willian Ferreira Moya — Tue, 15 Apr 2025 16:00:00 +0000

The @Profile annotation in Spring allows you to segregate configurations to be available only in specific environments.

If you mark a @Component (and its specializations) or any @Configuration or @Bean with the @Profile annotation, it will make them available only if the profile specified is active.

You can set the profile using application.properties by using the spring.profiles.active property, or by specifying it in the command line when running the application.

You can also use the spring.profiles.include property to add and combine more configuration profiles.

Let’s explore some examples.

Using profiles to separate environments

In your application, you may have a database connection, but you need to deal with new features and test them in a separate environment. You need a validation environment before shipping your new feature to production. We can call this environment dev.

And for the stable things that are running for all users of your application, you have a prod environment.

Each environment has its own database. You can use profiles to set up your application pointing to the right environment. In this case, it will point to the right data source for the environment, but you can separate many other things if needed.

So you can have a bean data source for the dev profile that is pointing to the dev database:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import javax.sql.DataSource;
import org.apache.commons.dbcp2.BasicDataSource;

@Configuration
@Profile("dev")
public class DevDataSourceConfig {

    @Bean
    public DataSource dataSource() {
        BasicDataSource dataSource = new BasicDataSource();
        dataSource.setUrl("jdbc:h2:mem:devdb");
        dataSource.setUsername("devuser");
        dataSource.setPassword("devpass");
        return dataSource;
    }
}

And another bean configuration for the prod profile is pointing to the production data source:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import javax.sql.DataSource;
import org.apache.commons.dbcp2.BasicDataSource;

@Configuration
@Profile("prod")
public class ProdDataSourceConfig {

    @Bean
    public DataSource dataSource() {
        BasicDataSource dataSource = new BasicDataSource();
        dataSource.setUrl("jdbc:mysql://prodserver:3306/proddb");
        dataSource.setUsername("produser");
        dataSource.setPassword("prodpass");
        return dataSource;
    }
}

(In the above code, I created a dummy class called BasicDataSource, which implements DataSource just to exemplify.)

When you run your application without setting a profile, this log will be shown, telling that Spring is using the default profile:

2024-07-17T21:50:05.329-03:00  INFO 18568 --- [           main] com.spring.mastery.MasteryApplication    : No active profile set, falling back to 1 default profile: "default"

You can set the profile in the application.properties like this:

spring.profiles.active=dev

This log will show up:

2024-07-17T21:52:03.996-03:00  INFO 8240 --- [           main] com.spring.mastery.MasteryApplication    : The following 1 profile is active: "dev"

Spring will load the data source connection to the dev environment.

You can set the profile in the command line:

Using VM arguments:

java -jar -Dspring.profiles.active=prod application.jar

Or you can use program arguments:

java -jar application.jar --spring.profiles.active=prod

Now, when running your application, you choose the profile that the scenario needs.

Combining Profiles

Another interesting thing you could do is combine two different profiles.

Let’s suppose that you have to do a test, and in this test, you want to load up the real cache manager bean that is used by your application and combine it with the test database.

In this case, we are going to call the profile that holds the cache manager as common and the test profile that has the data source configuration for the test database.

In your properties, you can set up the active environment as a test, and include the other profiles that you need.

Like this in application.properties:

spring.profiles.active=test
spring.profiles.include=common

So your Cache Manager is configured as the Common Profile:

import org.springframework.cache.CacheManager;
import org.springframework.cache.concurrent.ConcurrentMapCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;

@Configuration
@Profile("common")
public class CommonConfig {

    @Bean
    public CacheManager cacheManager() {
        log.info("Loading cache manager from common profile");
        return new ConcurrentMapCacheManager("entities");
    }
}

Your Test Profile points to the test data source:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import javax.sql.DataSource;
import org.apache.commons.dbcp2.BasicDataSource;

@Configuration
@Profile("test")
public class TestDataSourceConfig {

    @Bean
    public DataSource dataSource() {
        log.info("Loading data source bean from the test profile");
        BasicDataSource dataSource = new BasicDataSource();
        dataSource.setUrl("jdbc:h2:mem:testdb");
        dataSource.setUsername("testuser");
        dataSource.setPassword("testpass");
        return dataSource;
    }
}

When you run your application, you will have the beans from both profiles available and set.

A log line like this will show up:

The following 2 profiles are active: "common", "test"

In this blog post, we did this only with @Bean and @Configuration classes, but you could use this for all @Component and specializations too!

When used in a @Configuration class, it will set all the @Beans in it to the specific profile.

Now you’ve learned how to use the @Profile annotation in your project. Have you seen this annotation before? Can you think of more usages for this annotation? Share your thoughts with me in the comments or on social media.

If you like this topic, make sure to follow me. In the following days, I’ll be explaining more about Spring annotations! Stay tuned!

Willian Moya (@WillianFMoya) / X (twitter.com)

Willian Ferreira Moya | LinkedIn

What is @Component and How to Use It in Spring

Willian Ferreira Moya — Thu, 10 Apr 2025 01:56:02 +0000

What is `@Component`?

@Component is a stereotype annotation from the Spring framework that allows you to mark your classes as Spring components. These classes will be managed by Spring and will be available in the Spring IoC container, so they can be injected into other classes (also managed by Spring) through the @Autowired annotation.

Use this annotation when you need to create an application component that does not deal with business logic, or when it does not fit into web, service, or repository layers. It's a more generic type. If you're not sure which stereotype to use, @Component is a good choice.

Why use `@Component`?

It marks your class for Spring to auto-detect and register it into the Spring IoC container.
It facilitates component injection and dependency management.
It makes it easier to create more flexible classes due to the inversion of control. You can add properties to your component and manage these properties from an external configuration, allowing you to change values without recompiling and redeploying your application.

How to use `@Component`

This annotation is simple to use. Define a class with @Component:

@Component
public class MyComponent {
    public void doSomething() {
        System.out.println("Doing something...");
    }
}

Now your bean is already managed by Spring (if it's been scanned by Spring; check the @ComponentScan article to understand how this works). It will be available for injection with @Autowired like this:

@Service
public class MyService {
    private final MyComponent myComponent;

    @Autowired
    public MyService(MyComponent myComponent) {
        this.myComponent = myComponent;
    }

    public void performAction() {
        myComponent.doSomething();
    }
}

In the example above, MyService uses @Autowired to inject MyComponent.

@Component is an important Spring tool that helps create and manage parts of your program. It's useful when you need to connect different parts of your code. Use @Component when you're unsure if your class should be a controller, service, or repository.

If you like this topic, make sure to follow me. I’ll be explaining more about Spring annotations! Stay tuned!

Willian Moya (@WillianFMoya) / X (twitter.com)

Willian Ferreira Moya | LinkedIn

DEV Community: Willian Ferreira Moya

A Simple Guide to AOP in Spring Boot

What Is

Why Is Important

How To Use It

Dependencies

Step 1

Step 2

Step 3

Example

Conclusion

Understanding @Repository in Spring

What is @Repository?

Why is it important?

How to use @Repository

JpaRepository

CrudRepository

Dependencies

Conclusion

What is @Service In Spring?

Why is it important?

How to use it?

Let’s test it

Conclusion

Understanding @RestController in Spring Boot

What is it?

How to use it?

Conclusion

How to Use @PropertySource in Your Spring Application

What is the @PropertySource annotation?

Why use @PropertySource?

How to use @PropertySource

How to Use @Controller in Spring

What is?

Why is this important

How to use @Controller

Defining a controller class

Defining an endpoint and its respective HTTP method

Testing

Testing @Controller without REST

Creating a REST endpoint with @ResponseBody

Testing @Controller with @ResponseBody

Conclusion

Understanding the @Configuration Annotation in Spring

Let's see it in practice.

Understanding the @Scope Annotation in Spring: How Bean Scopes Work

What is @Scope

Why is it important:

How to use @Scope

Defining a service with @Scope in singleton mode

Defining a bean with scope set to prototype

Using a proxy and a custom scope (request-scoped example)

Conclusion

Spring Essentials: How to Use the @Bean Annotation for Custom Services

Creating a Custom Bean

Using the Custom Bean

Modifying a Bean

Spring Framework Essentials: Understanding @ComponentScan

How to Use Spring's @Profile Annotation for Flexible Configurations

Using profiles to separate environments

Combining Profiles

What is @Component and How to Use It in Spring

What is @Component?

Why use @Component?

How to use @Component

What is `@Repository`?

How to use `@Repository`

What is the `@PropertySource` annotation?

Why use `@PropertySource`?

How to use `@PropertySource`

What is `@Scope`

How to use `@Scope`

Defining a service with `@Scope` in singleton mode

What is `@Component`?

Why use `@Component`?

How to use `@Component`