Comprehensive Guide to Common Spring Framework Annotations

Core Annotations

@Required marks a bean setter as mandatory; if the property is not injected, a BeanInitializationException is thrown.

@Autowired can be placed on fields, setters, or constructors to declare a dependency that Spring resolves by type.

Example of field injection:

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

Example of setter injection with custom code:

@Component
public class User {
    private Address address;

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

Constructor injection (only one constructor may be annotated; after Spring 4.3 it is optional if there is a single constructor):

@Component
public class User {
    private Address address;

    public User(Address address) {
        this.address = address;
    }
}

@Qualifier works with @Autowired to disambiguate which bean should be injected when multiple candidates exist.

@Component
public class User {
    @Autowired
    @Qualifier("address1")
    private Address address;
}

@Configuration indicates that a class declares one or more @Bean methods and may be processed by the Spring container to generate bean definitions.

@Configuration
public class SpringCoreConfig {
    @Bean
    public AdminUser adminUser() {
        return new AdminUser();
    }
}

@ComponentScan is typically used together with @Configuration to specify the packages that Spring should scan for annotated components.

@Lazy can be placed on a component class or on individual @Bean methods to defer bean instantiation until it is first needed.

@Value injects property values or Spring Expression Language (SpEL) results into fields, constructor parameters, or method parameters.

Stereotype Annotations

@Component declares a generic Spring-managed component.

@Controller marks a class as a Spring MVC controller; it is a specialized form of @Component .

@Service indicates that a class holds business logic; also a specialization of @Component .

@Repository designates a DAO component, enabling exception translation for database access.

Spring Boot Annotations

@EnableAutoConfiguration tells Spring Boot to automatically configure beans based on the classpath.

@SpringBootApplication combines @Configuration , @EnableAutoConfiguration , and @ComponentScan for a Spring Boot entry point.

Spring MVC and REST Annotations

@RequestMapping maps HTTP requests to handler classes or methods; method‑level variants such as @GetMapping , @PostMapping , @PutMapping , @PatchMapping , and @DeleteMapping provide shortcut mappings for specific HTTP verbs.

@Controller
@RequestMapping("/users")
public class UserController {
    @RequestMapping(method = RequestMethod.GET)
    public String getUserList() {
        return "users";
    }
}

@CookieValue binds a specific cookie value to a method parameter.

@RequestMapping("/cookieValue")
public void getCookieValue(@CookieValue("JSESSIONID") String cookie) {
    // ...
}

@CrossOrigin enables CORS support on a controller or method.

@CrossOrigin(maxAge = 3600)
@RestController
@RequestMapping("/users")
public class AccountController {
    @CrossOrigin(origins = "http://xx.com")
    @RequestMapping("/login")
    public Result userLogin() {
        // ...
    }
}

@ExceptionHandler , @InitBinder , @MatrixVariable , @PathVariable , @RequestAttribute , @RequestBody , @RequestHeader , @RequestParam , @RequestPart , @ResponseBody , @ResponseStatus , and @ControllerAdvice provide fine‑grained control over request handling, data binding, and exception processing.

Data Access Annotations

@Transactional can be placed on classes or methods to indicate that the execution should be wrapped in a transaction; the annotation itself is metadata consumed by transaction managers.

Task Execution and Scheduling Annotations

@Scheduled marks a method for periodic execution. Fixed‑delay waits for the previous execution to finish; fixed‑rate does not.

@Scheduled(fixedDelay = 1000)
public void schedule() { }

@Scheduled(fixedRate = 1000)
public void scheduleG() { }

@Async indicates that a method should run in a separate thread, optionally returning a Future .

Testing Annotations

@ContextConfiguration together with @RunWith(SpringJUnit4ClassRunner.class) loads a Spring context for integration tests.

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringCoreConfig.class)
public class UserServiceTest { }