spring annotation ทั้งหมด

1. 1. Core Application Annotations:
   • @SpringBootApplication: Marks the main class of a Spring Boot application, combining @Configuration, @EnableAutoConfiguration, and @ComponentScan.
   Java

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

   2. Web Layer (REST) Annotations:
   • @RestController: Combines @Controller and @ResponseBody, indicating a class handles RESTful requests and its methods return data directly as the response body.
   • @RequestMapping: Maps HTTP requests to handler methods. Can be used at class or method level.
   • @GetMapping, @PostMapping, @PutMapping, @DeleteMapping: Specific HTTP method mapping annotations for cleaner code.
   • @PathVariable: Binds a method parameter to a URI template variable.
   • @RequestParam: Binds a method parameter to a web request parameter.
   • @RequestBody: Binds the HTTP request body to a method parameter.
   • @ResponseBody: Indicates that the return value of a method should be bound to the web response body.
   Java

       @RestController
       @RequestMapping("/api/products")
       public class ProductController {
   
           @GetMapping("/{id}")
           public Product getProductById(@PathVariable Long id) {
               // ...
               return product;
           }
   
           @PostMapping
           public Product createProduct(@RequestBody Product product) {
               // ...
               return savedProduct;
           }
       }

   3. Dependency Injection and Configuration:
   • @Autowired: Automatically injects dependencies by type.
   • @Qualifier: Specifies which bean to inject when multiple beans of the same type exist.
   • @Value: Injects values from properties files or environment variables.
   • @Component, @Service, @Repository: Stereotype annotations for marking classes as Spring components, services, or data access objects, respectively, enabling component scanning.
   • @Configuration: Indicates a class provides bean definitions.
   • @Bean: Marks a method as a bean factory method within a @Configuration class.
   Java

       @Service
       public class ProductService {
           @Autowired
           private ProductRepository productRepository;
   
           @Value("${app.name}")
           private String appName;
   
           // ...
       }
   
       @Configuration
       public class AppConfig {
           @Bean
           public MyBean myBean() {
               return new MyBean();
           }
       }

   4. Data Access and Transactions:
   • @Entity: Marks a class as a JPA entity.
   • @Table, @Column, @Id: JPA annotations for mapping entities to database tables and columns.
   • @Transactional: Manages transactions for methods or classes.
   Java

       @Entity
       @Table(name = "products")
       public class Product {
           @Id
           private Long id;
           private String name;
           // ...
       }
   
       @Service
       public class OrderService {
           @Transactional
           public void placeOrder(Order order) {
               // ...
           }
       }

   5. Conditional Annotations:
   • @ConditionalOnProperty: Creates a bean only if a specific property is present and/or has a particular value.
   • @ConditionalOnClass: Creates a bean only if a specific class is on the classpath.
   Java

       @Configuration
       @ConditionalOnProperty(name = "feature.enabled", havingValue = "true")
       public class FeatureConfig {
           // ...
       }

   6. Testing Annotations:
   • @SpringBootTest: Loads the entire application context for integration tests.
   • @WebMvcTest: Focuses testing on the web layer, mocking other layers.
   • @DataJpaTest: Focuses testing on JPA components.
   • @MockBean: Adds mocks to the Spring application context.
   Java

       @SpringBootTest
       public class MyIntegrationTest {
           // ...
       }