Shulou(Shulou.com)06/03 Report--

This article mainly introduces "what are the most commonly used class annotations in Spring". In daily operation, I believe that many people have doubts about the most commonly used class annotations in Spring. Xiaobian consulted all kinds of materials and sorted out simple and easy-to-use operation methods. I hope it will be helpful for you to answer the questions of "what are the most commonly used class annotations in Spring?" Next, please follow the editor to study!

one。 Core comment @ Required

This annotation is used on the setter method of bean. Indicates that this property is required and must be injected during the configuration phase, otherwise a BeanInitializationExcepion will be thrown.

@ Autowired

This annotation is used on bean's field, setter methods, and constructors to explicitly declare dependencies. Autowiring according to type.

When you use this annotation on a field and use properties to pass values, Spring automatically assigns values to the field. You can also use this annotation for private attributes (not recommended), as follows.

@ Componentpublic class User {@ Autowired private Address address;}

The most common use is to use this annotation on settter so that you can add custom code to the setter method. As follows:

@ Componentpublic class User {private Address address; @ AutoWired public setAddress (Address address) {/ / custom code this.address=address;}}

When using this annotation on a constructor, it is important to note that only one constructor in a class is allowed to use this annotation. In addition, after Spring4.3, if a class has only one constructor, then Spring will automatically inject the relevant bean even if this annotation is not used. As follows:

@ Componentpublic class User {private Address address; public User (Address address) {this.address=address;}} @ Qualifier

This annotation is used with @ Autowired. Using this annotation gives you more control over the injection process.

@ Qualifier can be used on the parameters of a single constructor or method. When the context has several bean of the same type, you can't tell the bean to bind using @ Autowired, so you can use @ Qualifier to specify the name. A complete Java interview dictionary has been sorted out and PDF has been compiled into a document.

@ Componentpublic class User {@ Autowired @ Qualifier ("address1") private Address address;.} @ Configuration

This annotation is used to define bean on class. It works the same as the xml configuration file, indicating that this bean is an Spring configuration. In addition, this class can use the @ Bean annotation to initialize the definition of bean.

@ Configuartionpublic class SpringCoreConfig {@ Bean public AdminUser adminUser () {AdminUser adminUser = new AdminUser (); return adminUser;}} @ ComponentScan

This annotation is typically used with the @ Configuration annotation to specify the package on which the Spring scans the annotation. If no package is specified, the package where this configuration class is located is scanned by default.

@ Lazy

This annotation is used on the component classes of Spring. By default, dependencies for Bean in Spring are created and configured from the start. If you want to delay initializing a bean, you can use Lazy annotations on this class to indicate that the bean will only be created and initialized the first time it is used. This annotation can also be used on classes annotated by @ Configuration, indicating that all methods annotated by @ Bean will be delayed initialization.

@ Value

This annotation is used on fields, constructor parameters, and method parameters. @ Value can specify an expression for the value of an attribute, which supports the use of SpringEL through # {} and the use of ${} to inject values from attribute sources (Properties files, local environment variables, system properties, etc.) into the properties of bean. The injection of this annotated value occurs in the AutowiredAnnotationBeanPostProcessor class.

two。 Spring MVC and REST annotations @ Controller

This annotation is used to declare on class that this class is a Spring controller, a concrete form of the @ Component annotation.

@ RequestMapping

This annotation can be used on class and method to map web requests to a handler class or handler method. When this annotation is used on Class, a base url is created, and the @ RequestMapping on all its methods is on top of this url.

You can use its method property to restrict the http method that the request matches.

@ Controller@RequestMapping ("/ users") public class UserController {@ RequestMapping (method = RequestMethod.GET) public String getUserList () {return "users";}}

In addition, Spring4.3 has since introduced a series of @ RequestMapping variants. As follows:

@ GetMapping

@ PostMapping

@ PutMapping

@ PatchMapping

@ DeleteMapping

Correspond to the RequestMapping configuration of the corresponding method respectively.

@ CookieValue

This annotation is used on the parameters of the method declared by @ RequestMapping, which binds the cookie of the corresponding name in the HTTP cookie.

@ ReuestMapping ("/ cookieValue") public void getCookieValue (@ CookieValue ("JSESSIONID") String cookie) {}

Cookie is the cookie value for which name is JSESSIONID in the http request.

@ CrossOrigin

This annotation is used on class and method 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 a target Exception.

@ InitBinder

This annotation is used on the method to declare the initialization of the WebDataBinder (binding the request parameter to DataBinder on the JavaBean). Use this annotation on controller to customize the binding of request parameters.

@ MatrixVariable

This annotation is used on the parameters of the request handler method, and the Spring can inject the relevant values in the matrix url. The matrix variables here can appear anywhere in the url, 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.

Annotation configuration needs to be enabled as follows:

@ Configurationpublic class WebConfig extends WebMvcConfigurerAdapter {@ Override public void configurePathMatch (PathMatchConfigurer configurer) {UrlPathHelper urlPathHelper = new UrlPathHelper (); urlPathHelper.setRemoveSemicolonContent (false); configurer.setUrlPathHelper (urlPathHelper);}} @ PathVariable

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 parameters in the path to request method parameters.

@ RequestMapping ("/ users/ {uid}") public String execute (@ PathVariable ("uid") String uid) {} @ RequestAttribute

This annotation is used on the parameters of the request handler method to bind the property (request attributes, which is the property value placed by the server) in the web request to the method parameter.

@ RequestBody

This annotation is used on the parameter 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 to request the handler method. Similar to @ RequestBody, it is used to output the return object of the method directly 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 Controller so that all @ RequestMapping inherits. A complete Java interview dictionary has been sorted out and PDF has been compiled into a document.

@ ControllerAdvice

This note is used on class. As mentioned earlier, you can declare an ExceptionMethod for each controller. You can use @ ControllerAdvice to declare a class to uniformly handle @ ExceptionHandler, @ InitBinder, and @ ModelAttribute for all @ RequestMapping methods.

@ RestController

This annotation is used on class to declare that this controller returns not a view but a domain object. It introduces both @ Controller and @ ResponseBody annotations.

@ RestControllerAdvice

This annotation is used on class, introducing both @ ControllerAdvice and @ ResponseBody annotations.

@ SessionAttribute

This annotation is used on the parameters of the method and is used to bind properties in session to parameters.

@ SessionAttributes

This annotation is used at the type level to store JavaBean objects in session. It is generally used with @ ModelAttribute annotations. As follows:

@ ModelAttribute ("user") public PUser getUser () {} / / controller and the above code are in the same controller @ Controller@SeesionAttributes (value = "user", types = {User.class}) public class UserController {} three. Spring Boot comment @ EnableAutoConfiguration

This annotation is usually used on the main application class, telling Spring Boot to automatically add Bean based on the current package, set the properties of bean, and so on.

@ SpringBootApplication

This annotation is used on the application main class of the Spring Boot project (this class needs to be in base package). Classes that use this annotation will first have Spring Boot start component scan of base package and its classes under its sub-pacakage.

This comment also adds the following comments:

@ Configuration

@ EnableAutoConfiguration

@ ComponentScan

four。 Stereotype comment @ Component

This annotation is used to declare a Spring component (Bean) on class to add it to the application context.

@ Controller

It has been mentioned earlier.

@ Service

This annotation is used on class, declaring that this class is a service class that performs business logic, calculates, invokes internal api, and so on. Is a concrete form of the @ Component annotation.

@ Repository

This type of use declares on class that this class is used to access the database, typically as the role of DAO.

This annotation has the feature of automatic translation, for example, when this component throws an exception, there will be a handler to handle the exception without using a try-catch block.

five。 Data access annotations @ Transactional

This annotation is used on interface definitions, methods in interfaces, class definitions, or public methods in classes. It is important to note that this annotation does not activate transaction behavior, it is just a metadata that will be consumed by some runtime infrastructure.

six。 Task execution, scheduling annotations @ Scheduled

This annotation is used on the method, declaring that the method is scheduled. The return type of the method that uses 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 does not wait for the end of the last task.

@ Async

This annotation is used on a method, declaring that the method will be executed in a separate thread. Unlike Scheduled comments, this annotation can accept parameters.

The return type of a method using this annotation can be Void or a return value. But the type of the return value must be a Future.

seven。 Test comment @ ContextConfiguration

This annotation is used on Class to declare the configuration file used by the test, and you can also specify the class to load the context.

This annotation generally needs to be used with SpringJUnit4ClassRunner. A complete Java interview dictionary has been sorted out and PDF has been compiled into a document.

@ RunWith (SpringJUnit4ClassRunner.class) @ ContextConfiguration (classes = SpringCoreConfig.class) public class UserServiceTest {} at this point, the study of "what are the most commonly used class annotations for Spring" is over. I hope I can solve your doubts. The collocation of theory and practice can better help you learn, go and try it! If you want to continue to learn more related knowledge, please continue to follow the website, the editor will continue to work hard to bring you more practical articles!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.