What are the knowledge points of SpringBoot annotations?

1. List of annotations

@SpringBootApplication: Contains @ComponentScan, @Configuration and @EnableAutoConfiguration annotations. Among them, @ComponentScan allows spring Boot to scan the Configuration class and add it to the program context.

@Configuration is equivalent to spring's XML configuration file; type safety can be checked using Java code.

@EnableAutoConfiguration automatic configuration.

@ComponentScan component scanning can automatically discover and assemble some beans.

@Component can be used with CommandLineRunner to perform some basic tasks after the program starts.

The @RestController annotation is a collection of @Controller and @ResponseBody, indicating that this is a controller bean, and the return value of the function is directly filled in the HTTP response body, which is a REST-style controller.

@Autowired automatic import.

@PathVariable gets the parameters.

@JsonBackReference solves the problem of nested external links.

@RepositoryRestResourcepublic is used with spring-boot-starter-data-rest.

2. Detailed explanation of annotations

@SpringBootApplication: Declares that spring boot automatically configures the program necessary. This configuration is equivalent to: @Configuration, @EnableAutoConfiguration and @ComponentScan three configurations.

import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication // same as

@Configuration

@EnableAutoConfiguration

@ComponentScanpublic class Application {

public static void main(String[] args) {

SpringApplication.run(Application.class, args);

}

}

@ResponseBody: Indicates that the return result of this method is directly written into the HTTP response body. It is generally used when obtaining data asynchronously and is used to build RESTful APIs. . 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. This annotation is generally used in conjunction with @RequestMapping. Sample code:

@RequestMapping(“/test”)@ResponseBodypublic String test(){ return”ok”;}

@Controller: used to define the controller class, in the spring project The controller is responsible for forwarding the URL request sent by the user to the corresponding service interface (service layer). Generally, this annotation is in the class, and usually the method needs to be accompanied by the annotation @RequestMapping. Sample code:

@Controller@RequestMapping("/demoInfo") public class DemoController {

@Autowired private DemoInfoService demoInfoService;

@RequestMapping("/hello") public String hello(Map map){ System.out.println("DemoController.hello()");

map.put("hello","from TemplateController.helloHtml"

);

//Will use hello.html or hello.ftl template for rendering and display.

return"/hello";

}

}

@RestController: used to annotate control layer components (such as actions in struts), a collection of @ResponseBody and @Controller. Sample code:

import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController; @RestController@RequestMapping(“/demoInfo2”)publicclass DemoController2 {

@RequestMapping("/test") public String test(){ return"ok";

}

}

@RequestMapping: Provide routing information, Responsible for mapping URLs to specific functions in Controller.

@EnableAutoConfiguration: Spring Boot automatic configuration (auto-configuration): Try to automatically configure your Spring application based on the jar dependencies you added. For example, if HSQLDB exists on your classpath and you have not manually configured any database connection beans, then we will automatically configure an in-memory database. You can add the @EnableAutoConfiguration or @SpringBootApplication annotation to a @Configuration Class to select auto-configuration. If you find that specific auto-configuration classes that you don’t want are applied, you can use the exclusion attribute of the @EnableAutoConfiguration annotation to disable them.

@ComponentScan: Indicates that the class will be automatically discovered and scanned for components. My personal understanding is that if classes with @Component, @Controller, @Service and other annotations are scanned and registered as beans, all Spring components, including @Configuration classes, can be automatically collected. We often use the @ComponentScan annotation to search for beans. And combined with the @Autowired annotation to import. All Spring components can be automatically collected, including the @Configuration class. We often use the @ComponentScan annotation to search for beans, and combined with the @Autowired annotation to import. If there is no configuration, Spring Boot will scan the package where the startup class is located As well as classes under sub-packages that use @Service, @Repository and other annotations.

@Configuration: Equivalent to the traditional xml configuration file. 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.

@Import: used to import other configuration classes.

@ImportResource: used to load xml configuration files.

@Autowired: Automatically import dependent beans

@Service: Generally used to modify components of the service layer

@Repository: Use the @Repository annotation to 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.

@Bean: The method marked with @Bean is equivalent to the bean configured in XML.

@Value: Inject the value of the property configured by Spring boot application.properties. Sample code:

@Value(value = “#{message}”)private String message;

@Inject: Equivalent to the default @Autowired, but without the required attribute;

@Component: Generally refers to components. When components are difficult to classify, we can use this annotation to annotate them.

@Bean: Equivalent to XML, placed above the method instead of the class, which means to generate a bean and hand it over to spring for management.

@AutoWired: Automatically import dependent beans. 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.

@Qualifier: When there are multiple beans of the same type, you can use @Qualifier("name") to specify. Used with @Autowired. In addition to being able to inject based on name, the @Qualifier qualified descriptor can provide more fine-grained control over how to select candidates. The specific usage is as follows:

@Autowired@Qualifier(value = “demoInfoService”)private DemoInfoService demoInfoService ;

@Resource(name="name",type="type"): If there is no content in brackets, it defaults to byName. Do similar things with @Autowired.

3. JPA annotations

@Entity: @Table(name=""): Indicates that this is an entity class. Generally used in jpa, these two annotations are generally used together, but if the table name and entity class name are the same, @Table can be omitted.

@MappedSuperClass: Used on entities that are determined to be parent classes. Subclasses can inherit the attributes of the parent class.

@NoRepositoryBean: Generally used as the repository of the parent class. With this annotation, spring will not instantiate the repository.

@Column: If the field name is the same as the column name, it can be omitted.

@Id: Indicates that this attribute is the primary key.

@GeneratedValue(strategy = GenerationType.SEQUENCE,generator = “repair_seq”): Indicates that the primary key generation strategy is sequence (can be Auto, IDENTITY, native, etc., Auto means that it can switch between multiple databases), specified The name of sequence is repair_seq.

@SequenceGeneretor(name = “repair_seq”, sequenceName = “seq_repair”, allocationSize = 1): name is the name of the sequence for easy use, sequenceName is the sequence name of the database, and the two names can be consistent.

@Transient: Indicates that this attribute is not a mapping to a field in a database table, and the ORM framework will ignore this attribute. If an attribute is not a field mapping of a database table, it must be marked as @Transient. Otherwise, the ORM framework defaults to the @Basic annotation. @Basic(fetch=FetchType.LAZY): The tag can specify the loading method of entity attributes

@JsonIgnore: The function is to ignore some properties in Java beans during json serialization. Both serialization and deserialization Affected.

@JoinColumn(name="loginId"): One-to-one: a foreign key in this table pointing to another table. One-to-many: A foreign key from another table pointing to this table.

@OneToOne, @OneToMany, @ManyToOne: correspond to one-to-one, one-to-many, and many-to-one in the hibernate configuration file.

4. SpringMVC Related Notes

@RequestMapping: @RequestMapping("/path") indicates that the controller handles all "/path" URL requests. RequestMapping is an annotation used to handle request address mapping, which can be used on classes or methods. Used on a class, it means that all methods in the class that respond to requests use this address as the parent path. This annotation has six attributes:

params: The specified request must contain certain parameter values ​​before it can be processed by this method. headers: The specified request must contain certain specified header values ​​in order for this method to process the request. value: Specify the actual address of the request. The specified address can be a URI Template. Mode method: Specify the method type of the request, such as GET, POST, PUT, DELETE, etc. consumes: Specify the submission content type (Content-Type) for processing the request, such as application/ json, text/html;produces: Specifies the content type to be returned. Only when the (Accept) type in the request header contains the specified type, it will be returned

@RequestParam: used in front of the parameters of the method. @RequestParamString a =request.getParameter("a").

@PathVariable: Path variable. For example,

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

Parameters and names in curly brackets The same must be the same.

5. Global exception handling

@ControllerAdvice: Contains @Component. can be scanned. Handle exceptions uniformly.

@ExceptionHandler (Exception.class): Used on a method to indicate that the following method will be executed when encountering this exception.

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