Med Java

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== Spring Annotations Guide ======

This page provides a quick reference for the main Spring annotations and their usage, categorized by their purpose and role in a Spring application.

===== 1. Core Component Annotations =====
These annotations are used to mark classes as Spring-managed components.

  * **@Component**  
    - General-purpose annotation for any Spring-managed component.
    - Use this when the class does not fit into a specific role like `@Service` or `@Repository`.
    - Example:
      <code java>
      @Component
      public class MyComponent {
          // General logic
      }
      </code>

===== 2. Service Layer Annotations =====
Annotations for classes that implement business logic.

  * **@Service**  
    - Specialized version of `@Component` for service classes.
    - Indicates that the class contains business logic.
    - Example:
      <code java>
      @Service
      public class MyService {
          public void performLogic() {
              // Business logic
          }
      }
      </code>

===== 3. Data Access Layer Annotations =====
Annotations for classes that interact with the database.

  * **@Repository**  
    - Specialized version of `@Component` for data access objects (DAO).
    - Enables automatic exception translation for database-related exceptions.
    - Example:
      <code java>
      @Repository
      public class MyRepository {
          public List<String> findAll() {
              // Database interaction
              return List.of("data1", "data2");
          }
      }
      </code>

===== 4. Web Layer Annotations =====
Annotations for handling HTTP requests in web applications.

  * **@Controller**  
    - Specialized version of `@Component` for web controllers.
    - Handles HTTP requests and returns views.
    - Example:
      <code java>
      @Controller
      public class MyController {
          @GetMapping("/hello")
          public String sayHello() {
              return "hello";
          }
      }
      </code>

  * **@RestController**  
    - Combines `@Controller` and `@ResponseBody`.
    - Used for REST APIs where methods return data (e.g., JSON).
    - Example:
      <code java>
      @RestController
      public class MyRestController {
          @GetMapping("/api/data")
          public List<String> getData() {
              return List.of("data1", "data2");
          }
      }
      </code>

===== 5. Configuration Annotations =====
Annotations for defining and managing Spring beans.

  * **@Configuration**  
    - Marks a class as a source of bean definitions.
    - Example:
      <code java>
      @Configuration
      public class AppConfig {
          @Bean
          public MyService myService() {
              return new MyService();
          }
      }
      </code>

  * **@Bean**  
    - Used within `@Configuration` classes to define individual beans.
    - Example:
      <code java>
      @Bean
      public MyComponent myComponent() {
          return new MyComponent();
      }
      </code>

===== 6. Dependency Injection Annotations =====
Annotations for injecting dependencies into Spring components.

  * **@Autowired**  
    - Automatically injects a dependency.
    - Can be used on constructors, fields, or methods.
    - Example:
      <code java>
      @Component
      public class MyComponent {
          private final MyService myService;

          @Autowired
          public MyComponent(MyService myService) {
              this.myService = myService;
          }
      }
      </code>

  * **@Qualifier**  
    - Specifies which bean to inject when multiple candidates are available.
    - Example:
      <code java>
      @Component
      public class MyComponent {
          @Autowired
          @Qualifier("specificService")
          private MyService myService;
      }
      </code>

  * **@Value**  
    - Injects values from configuration files (e.g., `application.properties`).
    - Example:
      <code java>
      @Component
      public class MyComponent {
          @Value("${app.name}")
          private String appName;
      }
      </code>

===== 7. Scope Annotations =====
Annotations for defining the scope of Spring beans.

  * **@Scope**  
    - Specifies the scope of a bean (`singleton`, `prototype`, etc.).
    - Example:
      <code java>
      @Component
      @Scope("prototype")
      public class MyPrototypeBean {
          // A new instance is created for each request
      }
      </code>

===== 8. Aspect-Oriented Programming (AOP) Annotations =====
Annotations for implementing cross-cutting concerns like logging or security.

  * **@Aspect**  
    - Marks a class as an aspect for AOP.
    - Example:
      <code java>
      @Aspect
      @Component
      public class LoggingAspect {
          @Before("execution(* com.example.*.*(..))")
          public void logBefore() {
              System.out.println("Logging before method execution");
          }
      }
      </code>

===== Summary Table =====
| **Role**                | **Annotation**      | **Description**                                      |
|-------------------------|---------------------|----------------------------------------------------|
| General Component       | `@Component`        | General-purpose Spring-managed component.          |
| Business Logic          | `@Service`          | Marks a service class for business logic.          |
| Data Access             | `@Repository`       | Marks a DAO or repository class.                   |
| Web Controller          | `@Controller`       | Handles HTTP requests and returns views.           |
| REST API Controller     | `@RestController`   | Handles REST API requests and returns data.        |
| Configuration           | `@Configuration`    | Defines Spring beans and configuration.            |
| Bean Definition         | `@Bean`             | Defines a bean explicitly in a configuration class.|
| Dependency Injection    | `@Autowired`        | Injects dependencies automatically.                |
| Dependency Selection    | `@Qualifier`        | Specifies which bean to inject.                    |
| Configuration Value     | `@Value`            | Injects values from configuration files.           |
| Bean Scope              | `@Scope`            | Defines the scope of a bean.                       |
| Aspect                  | `@Aspect`           | Marks a class as an AOP aspect.                    |

This guide provides a structured overview of the most commonly used Spring annotations to help you quickly identify and apply them in your projects.