What are the common annotations for springboot?

Commonly used annotations in springboot include: 1. SpringBootApplication; 2. Repository; 3. Service; 4. RestController; 5. ResponseBody; 6. Component, etc.

Commonly used annotations in springboot are:

1, @SpringBootApplication

This annotation is the core annotation of Spring Boot. It is used on the main class of Spring Boot to identify this as a Spring Boot application and is used to enable various capabilities of Spring Boot. In fact, this annotation is a combination of three annotations: @Configuration, @EnableAutoConfiguration, and @ComponentScan. Since these annotations are generally used together, Spring Boot provides a unified annotation @SpringBootApplication.

2. @EnableAutoConfiguration

Allow Spring Boot to automatically configure annotations. After turning on this annotation, Spring Boot can configure Spring based on the packages or classes in the current class path. Beans.

For example: There is the Mybatis JAR package under the current class path, and the MybatisAutoConfiguration annotation can configure each Spring Bean of Mybatis according to relevant parameters.

The key to the implementation of @EnableAutoConfiguration is the introduction of AutoConfigurationImportSelector. Its core logic is the selectImports method. The logic is roughly as follows:

● Load all possible components from the configuration file META-INF/spring.factories Automatic configuration classes;

● Remove duplication and exclude classes carried by the exclude and excludeName attributes;

● Filter and return automatic configuration classes that meet the conditions (@Conditional);

3. @Configuration

is used to define the configuration class, indicating that this class is the information source for Bean configuration, which is equivalent to the traditional xml configuration file and is generally added to the main class. If some third-party libraries need to use xml files, it is recommended to still use the @Configuration class as the main configuration class of the project - you can use the @ImportResource annotation to load the xml configuration file.

4. @ComponentScan

Component scan. Let spring Boot scan the Configuration class and add it to the program context.

The @ComponentScan annotation will assemble classes annotated with @Controller, @Service, @Repository, and @Component into the spring container by default.

5, @Repository

is used to mark data access components, that is, DAO components.

Using the @Repository annotation can ensure that DAO or repositories provide exception translation. The DAO or repositories class modified by this annotation will be discovered and configured by ComponentScan, and there is no need to provide XML configuration items for them.

6, @Service

Generally used to modify the components of the service layer

7, @RestController

is used to mark control layer components (such as action in struts), indicating that this is a controller bean, and the return value of the function is directly filled in the HTTP response body. It is a REST style controller; it is @Controller and Collection of @ResponseBody.

8, @ResponseBody

means that the return result of this method is directly written into the HTTP response body

is generally used when obtaining data asynchronously. After using @RequestMapping, the return value is usually parsed as a jump path. After adding @responsebody, the return result will not be parsed as a jump path, but will be written directly into the HTTP response body. For example, if you obtain json data asynchronously and add @responsebody, the json data will be returned directly.

9. @Component

refers to components in general. When components are difficult to classify, we can use this annotation to annotate them.

10. @Bean

is equivalent to 60e23eb984d18edbb092da6b8f295aba4bb0e59fd50cbfe6f6ce2215b9d94243 in XML. It is placed above the method instead of the class, which means to generate A bean and managed by spring.

11, @AutoWired

byType method. Use the configured beans to complete the assembly of properties and methods. It can annotate class member variables, methods and constructors to complete automatic assembly.

When (required=false) is added, no error will be reported even if the bean cannot be found.

12. @Qualifier

When there are multiple beans of the same type, you can use @Qualifier("name") to specify. Used in conjunction with @Autowired

13, @Resource(name="name",type="type")

If there is no content in brackets, byName will be used by default. Do similar things with @Autowired.

14, @RequestMapping

RequestMapping is an annotation used to process request address mapping; provides routing information and is responsible for mapping URLs to specific functions in Controller. Available on a class or method. Used on a class, it means that all methods in the class that respond to requests use this address as the parent path.

15. @RequestParam

is used in front of the parameters of the method. Example:

@RequestParam String a =request.getParameter("a")。

16, @PathVariable

Path variable. The parameters must be the same as the names in the curly brackets. Example:

RequestMapping("user/get/mac/{macAddress}")
public String getByMacAddress(@PathVariable String macAddress){
　　//do something;
}

17, @Profiles

Spring Profiles provide a way to isolate application configurations and allow these configurations to only take effect in specific environments .

任何@Component或@Configuration都能被@Profile标记，从而限制加载它的时机。

@Configuration
@Profile("prod")
public class ProductionConfiguration {
    // ...
}

18、@ConfigurationProperties

Spring Boot可使用注解的方式将自定义的properties文件映射到实体bean中，比如config.properties文件。

@Data
@ConfigurationProperties("rocketmq.consumer")
public class RocketMQConsumerProperties extends RocketMQProperties {
    private boolean enabled = true;
    private String consumerGroup;
    private MessageModel messageModel = MessageModel.CLUSTERING;
    private ConsumeFromWhere consumeFromWhere = ConsumeFromWhere.CONSUME_FROM_LAST_OFFSET;
    private int consumeThreadMin = 20;
    private int consumeThreadMax = 64;
    private int consumeConcurrentlyMaxSpan = 2000;
    private int pullThresholdForQueue = 1000;
    private int pullInterval = 0;
    private int consumeMessageBatchMaxSize = 1;
    private int pullBatchSize = 32;
}

以上就是本篇文章的全部内容，希望能对大家的学习有所帮助。更多精彩内容大家可以关注php中文网相关教程栏目！！！

The above is the detailed content of What are the common annotations for springboot?. For more information, please follow other related articles on the PHP Chinese website!