Preface
With the update and iteration of technology, Java 5.0 began to support annotations. As the leading framework in Java, spring has gradually abandoned the xml configuration since the 2.5 version was updated, and more uses annotations to control the spring framework. However, there are so many annotations in spring, which may not be used in java for many years.
So here I have summarized these 7 most commonly used annotations by type. I hope it can be helpful to you, please correct me if you are short of it.
1. Core Notes
@Required
This annotation is used on the setter method of the bean. Indicates that this attribute is required and must be injected during the configuration phase, otherwise BeanInitializationExcepion will be thrown.
@Autowired
This annotation is used in bean field, setter methods, and construction methods to explicitly declare dependencies. According to the type to autowiring.
When this annotation is used on the field and the attribute is used to pass the value, Spring will automatically assign the value to the field. You can also use this annotation for private attributes (not recommended), as follows.
@Component
public class User {
@Autowired
private Address address;
}The most common usage is to use this annotation on the setter so that you can add custom code in the setter method. as follows:
@Component
public class User {
private Address address;
@AutoWired
public setAddress(Address address) {
// custom code
this.address=address;
}
}When using this annotation on the constructor, one thing to note is that only one constructor in a class is allowed to use this annotation. In addition, after Spring 4.3, if a class has only one construction method, even if this annotation is not used, Spring will automatically inject related beans. as follows:
@Component
public class User {
private Address address;
public User(Address address) {
this.address=address;
}
}
<bean id="user" class="xx.User"/>@Qualifier
This annotation is used with @Autowired. Using this annotation allows you to have more control over the injection process.
@Qualifier can be used on the parameters of a single constructor or method. When there are several beans of the same type in the context, @Autowired cannot distinguish the beans to be bound. In this case, you can use @Qualifier to specify the name.
@Component
public class User {
@Autowired
@Qualifier("address1")
private Address address;
...
}@Configuration
This annotation is used on the class to define the bean. Its function is the same as the xml configuration file, which means that this bean is a Spring configuration. In addition, this class can use the @Bean annotation to initialize and define the bean.
@Configuartion
public class SpringCoreConfig {
@Bean
public AdminUser adminUser() {
AdminUser adminUser = new AdminUser();
return adminUser;
}
}@ComponentScan
This annotation is generally used together with the @Configuration annotation to specify the package of Spring scan annotations. If no package is specified, the package where this configuration class is located will be scanned by default.
@Lazy
This annotation is used on Spring component classes. By default, Bean dependencies in Spring are created and configured from the beginning. If you want to delay the initialization of a bean, you can use the Lazy annotation on this class, which means that the bean will only be created and initialized when it is used for the first time. This annotation can also be used on classes annotated by @Configuration, which means that all methods annotated by @Bean will be initialized lazily.
@Value
This annotation is used on fields, constructor parameters, and method parameters. @Value can specify the expression of the attribute value, support #{} to use SpringEL to get the value, and also support the use of ${} to inject the value of the attribute source (Properties file, local environment variable, system property, etc.) into the bean In the properties. The injection of this annotation value occurs in the AutowiredAnnotationBeanPostProcessor class.
Sorted out the real classic interview questions for Java engineers in 2021. A total of 485 pages of about 850 interview questions PDF with answers, including Java, MyBatis, ZooKeeper, Dubbo, Elasticsearch, Memcached, Redis, MySQL, Spring, Spring Boot, Spring Cloud , RabbitMQ, Kafka, Linux, etc. Almost all technology stacks, each technology stack has no less than 50 classic interview questions. I dare not say that you will enter a big factory after finishing the package, but the targeted application will let you face the interviewer. It’s okay to have a little more confidence when you do.
2. Spring MVC and REST annotations
@Controller
This annotation is used on the class to declare that this class is a Spring controller, which is a specific form of @Component annotation.
@RequestMapping
This annotation can be used on classes and methods to map web requests to a certain handler class or handler method. When this annotation is used on the Class, a basic url is created, and the @RequestMapping on all its methods are on this url.
You can use its method attribute to limit the http method that the request matches.
@Controller
@RequestMapping("/users")
public class UserController {
@RequestMapping(method = RequestMethod.GET)
public String getUserList() {
return "users";
}
}In addition, a series of @RequestMapping variants have been introduced after Spring 4.3. as follows:
@GetMapping
@PostMapping
@PutMapping
@PatchMapping
@DeleteMapping
Corresponding to the RequestMapping configuration of the corresponding method.
@CookieValue
This annotation is used on the parameters of the method declared by @RequestMapping to bind the cookie with the corresponding name in the HTTP cookie.
@ReuestMapping("/cookieValue")
public void getCookieValue(@CookieValue("JSESSIONID") String cookie){
}Cookie is the cookie value whose name is JSESSIONID in the http request.
@CrossOrigin
This annotation is used on classes and methods to support cross-domain requests and was introduced after Spring 4.2.
@CrossOrigin(maxAge = 3600)
@RestController
@RequestMapping("/users")
public class AccountController {
@CrossOrigin(origins = "http://xx.com")
@RequestMapping("/login")
public Result userLogin() {
// ...
}
}@ExceptionHandler
This annotation is used at the method level to declare the processing logic for Exception. You can specify the target Exception.
@InitBinder
This annotation is used on the method to declare the initialization of the WebDataBinder (bind the request parameters to the DataBinder on the JavaBean). Use this annotation on the controller to customize the binding of request parameters.
@MatrixVariable
This annotation is used on the parameters of the request handler method, and Spring can inject the relevant values in the matrix url. The matrix variables here can appear anywhere in the url, and the variables are separated by ;. as follows:
// GET /pets/42;q=11;r=22
@RequestMapping(value = "/pets/{petId}")
public void findPet(@PathVariable String petId, @MatrixVariable int q) {
// petId == 42
// q == 11
}It should be noted that the default Spring mvc does not support matrix variables and needs to be turned on.
<mvc:annotation-driven enable-matrix-variables="true" />The annotation configuration needs to be turned on as follows:
@Configuration
public class WebConfig extends WebMvcConfigurerAdapter {
@Override
public void configurePathMatch(PathMatchConfigurer configurer) {
UrlPathHelper urlPathHelper = new UrlPathHelper();
urlPathHelper.setRemoveSemicolonContent(false);
configurer.setUrlPathHelper(urlPathHelper);
}
}AthPathVariable
This annotation is used on the parameters of the request handler method. @RequestMapping can define dynamic paths, such as:
@RequestMapping("/users/{uid}")You can use @PathVariable to bind the parameters in the path to the request method parameters.
@RequestMapping("/users/{uid}")
public String execute(@PathVariable("uid") String uid){
}
@RequestAttributeThis annotation is used on the parameters of the request handler method to bind the attributes in the web request (request attributes, which are attribute values placed by the server) to the method parameters.
@RequestBody
This annotation is used on the parameters of the request handler method to bind the body mapping of the http request to this parameter. HttpMessageConverter is responsible for converting objects into http requests.
@RequestHeader
This annotation is used on the parameters of the request handler method to bind the value of the http request header to the parameter.
@RequestParam
This annotation is used on the parameters of the request handler method to bind the value of the http request parameter to the parameter.
@RequestPart
This annotation is used on the parameters of the request handler method to bind multipart such as files to the parameters.
@ResponseBody
This annotation is used on the request handler method. Similar to @RequestBody, it is used to directly output the returned object of the method to the http response.
@ResponseStatus
This annotation is used on methods and exception classes to declare the http status code returned by this method or exception class. You can use this annotation on the Controller so that all @RequestMapping will be inherited.
@ControllerAdvice
This annotation is used on the class. As mentioned earlier, you can declare an ExceptionMethod for each controller. Here you can use @ControllerAdvice to declare a class to uniformly handle all @RequestMapping methods @ExceptionHandler, @InitBinder, and @ModelAttribute.
@RestController
This annotation is used on the class to declare that what the controller returns is not a view but a domain object. It also introduces two annotations @Controller and @ResponseBody.
@RestControllerAdvice
This annotation is used on the class, and two annotations @ControllerAdvice and @ResponseBody are introduced at the same time.
@SessionAttribute
This annotation is used on the parameters of the method to bind the attributes in the session to the parameters.
@SessionAttributes
This annotation is used at the type level to store JavaBean objects in the session. Generally used with @ModelAttribute annotation. as follows:
@ModelAttribute("user")
public PUser getUser() {}
// controller和上面的代码在同一controller中
@Controller
@SeesionAttributes(value = "user", types = {
User.class
})
public class UserController {}Three. Spring Boot annotations
@EnableAutoConfiguration
This annotation is usually used on the main application class to tell Spring Boot to automatically add beans based on the current package, set bean properties, and so on.
@SpringBootApplication
This annotation is used in the application main class of the Spring Boot project (this class needs to be in the base package). The class with this annotation will first start Spring Boot to perform component scan on the base package and the classes under its sub-pacakage.
This note adds the following notes at the same time:
@Configuration
@EnableAutoConfiguration
@ComponentScan
Four, Stereotype annotation
@Component
This annotation is used on the class to declare a Spring component (Bean) and add it to the application context.
@Controller
As mentioned before
@Service
This annotation is used on the class to declare that this class is a service class, which executes business logic, calculations, and calls internal APIs. It is a specific form of @Component annotation.
@Repository
This class is used to declare this class on the class to access the database, generally as the role of DAO.
This annotation has the feature of automatic translation, for example: when this kind of component throws an exception, then there will be a handler to handle the exception without using a try-catch block.
V. Data Access Notes
@Transactional
This annotation is used in interface definitions, methods in interfaces, class definitions, or public methods in classes. It should be noted that this annotation does not activate transaction behavior, it is just a metadata that will be consumed by some runtime infrastructure.
6. Task execution and scheduling notes
@Scheduled
This annotation is used on methods to declare that this method is scheduled regularly. The return type of the method using this annotation needs to be Void and cannot accept any parameters.
@Scheduled(fixedDelay=1000)
public void schedule() {
}
@Scheduled(fixedRate=1000)
public void schedulg() {
}The second is different from the first in that it will not wait for the completion of the previous task execution.
@Async
This annotation is used on methods, stating that this method will be executed in a separate thread. Unlike Scheduled annotations, this annotation can accept parameters.
The return type of the method using this annotation can be Void or return value. But the type of the return value must be a Future.
7. Test notes
@ContextConfiguration
This annotation is used on the Class to declare the configuration file used for the test. In addition, you can also specify the class of the loading context.
This annotation generally needs to be used with SpringJUnit4ClassRunner.
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringCoreConfig.class)
public class UserServiceTest {
}