Spring Core Annotations

Spring Annotations are metadata in Java used to provide configuration and behavior information to the Spring Framework. They eliminate the need for XML-based configuration, making Spring applications more concise, readable, and easier to maintain.

In essence, annotations tell the Spring Container how to create, configure, and manage application components (beans). They are widely used for dependency injection, bean configuration, web components, and context management.

Types of Spring Framework Annotations

Spring Core Annotations: Dependency injection, bean lifecycle, and context configuration.
Spring Web Annotations: Used for building web and RESTful services.
Spring Boot Annotations: Simplify auto-configuration and bootstrapping.
Spring Scheduling Annotations: For task scheduling and asynchronous execution.
Spring Data Annotations: For JPA, repositories, and data persistence.
Spring Bean Annotations: For defining and managing beans.

Annotations in the org.springframework.beans.factory.annotation and org.springframework.context.annotation packages are collectively called Spring Core Annotations.

They can be divided into two main categories:

Dependency Injection (DI)-Related Annotations
Context Configuration Annotations

spring_core_annotations_ — Spring core annotations

DI-Related Annotations

These annotations are used to perform dependency injection and define how beans are created and wired together in the Spring container.

1. @Autowired

Automatically injects dependencies by type. It can be used on constructors, fields, or setter methods.

Example (Field Injection):

Java

@Component
public class Student {
    @Autowired
    private Address address;
}

Example (Constructor Injection):

Java

@Component
public class Student {
    private final Address address;

    @Autowired
    public Student(Address address) {
        this.address = address;
    }
}

Example (Setter Injection):

Java

@Component
public class Student {
    private Address address;

    @Autowired
    public void setAddress(Address address) {
        this.address = address;
    }
}

2. @Qualifier

Used with @Autowired to resolve conflicts when multiple beans of the same type exist. It specifies the exact bean name to be injected.

Java

@Component
public class VehicleService {
    @Autowired
    @Qualifier("bike")
    private Vehicle vehicle;
}

3. @Primary

Specifies a default bean when multiple beans of the same type are available for autowiring.

Java

@Configuration
public class Config {
    @Bean
    public Employee employee1() {
        return new Employee("Employee1");
    }

    @Bean
    @Primary
    public Employee employee2() {
        return new Employee("Employee2");
    }
}

4. @Bean

Indicates that a method produces a Spring-managed bean. Used inside @Configuration classes.

Java

@Configuration
public class AppConfig {
    @Bean
    public MyService myService() {
        return new MyService();
    }
}

5. @Lazy

Delays the initialization of a bean until it is first requested.

Java

@Component
@Lazy
public class MyService {
    // Initialized only when first accessed
}

6. @Value

Injects values from properties files, environment variables, or expression language.

Java

@Component
public class MyService {
    @Value("${app.name}")
    private String appName;
}

7. @Scope

Defines the scope of a Spring bean. Common scopes:

singleton (default)
prototype
request
session
application

Java

@Component
@Scope("prototype")
public class MyService {
}

8. @Lookup

Used for method injection, it allows a method to return a new instance of a prototype-scoped bean each time it’s called.

Java

@Component
public abstract class MyService {
    @Lookup
    public abstract MyBean getMyBean();
}

9. @Required (Deprecated)

Previously used to indicate that a property must be injected, now deprecated as of Spring 5.1.

Java

public class Employee {
    @Required
    public void setName(String name) {
        this.name = name;
    }
}

Context Configuration Annotations

These annotations are used to define how Spring discovers, configures, and loads beans into the ApplicationContext.

1. @Configuration

Marks a class as a source of bean definitions. Beans within this class are defined using @Bean methods.

Java

@Configuration
public class AppConfig {
    @Bean
    public MyService myService() {
        return new MyService();
    }
}

2. @ComponentScan

Specifies the base packages to scan for Spring-managed components like @Component, @Service, or @Repository.

Java

@Configuration
@ComponentScan("com.example")
public class AppConfig {
}

3. @Import

Used to import additional @Configuration classes into another configuration class.

Java

@Configuration
@Import({DatabaseConfig.class, SecurityConfig.class})
public class MainConfig {
}

4. @ImportResource

Imports legacy XML-based configurations into a Java-based configuration class.

Java

@Configuration
@ImportResource("classpath:app-config.xml")
public class AppConfig {
}

5. @PropertySource

Imports legacy XML-based configurations into a Java-based configuration class.

Java

@Configuration
@ImportResource("classpath:app-config.xml")
public class XmlConfig {
}

6. @Profile

Specifies that a bean should only be registered when a particular Spring profile is active.

Java

@Component
@Profile("dev")
public class DevDataSource {
    // Bean will be loaded only if the "dev" profile is active
}

7. @PropertySource

Loads a .properties file into the Spring environment so that property values can be injected using @Value.

Java

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

8. @Conditional

Conditionally registers a bean based on a custom condition class.

Java

@Bean
@Conditional(MyCondition.class)
public MyService myService() {
    return new MyService();
}

Spring Core Annotations

Types of Spring Framework Annotations