Why annotation in spring

DataBaseDriver is the base interface that we will implement. Notice the use of Component annotation to indicate spring framework to treat this class as a Component. We are also using PropertySource and Value annotations, Spring will use these at runtime to inject and set these variable values from specified property file.

Below is the properties declared in mysqldatabase. OracleDriver is a simple bean, we will use service class to inject properties to this bean. Here we are using Service annotation to indicate Spring framework to treat this as a Service class. Then we are using Autowired and Qualifier "oracleDriver" annotations to tell spring framework to inject bean named oracleDriver to class property dataBaseDriver. Notice the bean definition for oracleDriver. In this method, we are reading properties from oracledatabase.

Our spring annotations example project is ready to test. As a summary, we performed following steps:. Below image shows the output produced.

I have listed here most of the important annotations, but there are a lot more of them for specific tasks. You can download my spring annotations example project from below link. Reference: API Doc. Hi Pankaj. Spring Security Annotations. Spring supports both Annotation based and XML based configurations. You can even mix them together. Annotation injection is performed before XML injection, thus the latter configuration will override the former for properties wired through both approaches.

Spring beans can be wired by name or by type. Autowire by default is a type driven injection. Qualifier spring annotation can be used to further fine-tune autowiring. This annotation is used at both the class and method level. The RequestMapping annotation is used to map web requests onto specific handler classes and handler methods. When RequestMapping is used on the class level, it creates a base URI for which the controller will be used.

When this annotation is used on methods, it will give you the URI on which the handler methods will be executed. From this, you can infer that the class level request mapping will remain the same whereas each handler method will have their own request mapping.

The RequestMapping annotation is very versatile. Please see my in-depth post on Request Mapping here. This annotation is used at the method parameter level. CookieValue is used as an argument of a request mapping method. This annotation is used in the method annotated with RequestMapping. Let us consider that the following cookie value is received with an HTTP request:. This annotation is used both at the class and method levels to enable cross-origin requests. In many cases, the host that serves JavaScript will be different from the host that serves the data.

To enable this communication, you just need to add the CrossOrigin annotation. You can customize the behavior by specifying the corresponding attribute values. An example of using CrossOrigin at both the controller and handler method levels is below:. In this example, both the getExample and getNote methods will have a maxAge of seconds. Spring Framework 4. Using these annotations has become the standard ays of defining the endpoints.

They act as wrappers to RequestMapping. This annotation is used at method levels to handle exceptions at the controller level. The ExceptionHandler annotation is used to define the class of exception it will catch.

You can use this annotation on methods that should be invoked to handle an exception. The ExceptionHandler values can be set to an array of Exception types.

If an exception is thrown that matches one of the types in the list, then the method annotated with the matching ExceptionHandler will be invoked. This annotation is a method-level annotation that plays the role of identifying the methods that initialize the WebDataBinder — a DataBinder that binds the request parameter to JavaBean objects. To customize request parameter data binding, you can use InitBinder annotated methods within our controller.

The methods annotated with InitBinder includes all argument types that handler methods support. The value element can be a single or multiple form names or request parameters that the init binder method is applied to. This annotation is used on fields. The Mapping annotation is a meta-annotation that indicates a web mapping annotation.

When mapping different field names, you need to configure the source field to its target field, and to do that, you have to add the Mappings annotation. This annotation accepts an array of Mapping having the source and the target fields. This annotation is used to annotate request handler method arguments so that Spring can inject the relevant bits of a matrix URI. Matrix variables can appear on any segment each separated by a semicolon. The MatrixVariable annotation ensures that the request is matched with the correct matrix variables of the URI.

This annotation is used to annotate request handler method arguments. You can specify this parameter using a regular expression. The PathVariable annotation can be used to declare this parameter. This annotation is used to bind the request attribute to a handler method parameter. Spring retrieves the named attribute's value to populate the parameter annotated with RequestAttribute. While the RequestParamannotation is used to bind the parameter values from a query string, RequestAttribute is used to access the objects that have been populated on the server-side.

The RequestHeader annotation is used to map the controller parameter to request header value. When Spring maps the request, RequestHeader checks the header with the name specified within the annotation and binds its value to the handler method parameter. This annotation helps you to get the header details within the controller class. In that case, along with the RequestMapping annotation, you can use the RequestParam annotation to retrieve the URL parameter and map it to the method argument.

The RequestParam annotation is used to bind request parameters to a method parameter in your controller. The RequestPart annotation can be used instead of RequestParam to get the content of a specific multipart and bind it to the method argument annotated with RequestPart. This annotation is used to annotate request handler methods. The ResponseBody annotation is similar to the RequestBody annotation.

Spring converts the returned object into a response body by using the HttpMessageConveter. This annotation is used on methods and exception classes.

ResponseStatus marks a method or exception class with a status code and a reason that must be returned. When the handler method is invoked the status code is set to the HTTP response which overrides the status information provided by any other means. A controller class can also be annotated with ResponseStatus , which is then inherited by all RequestMapping methods.

This annotation is applied at the class level. As explained earlier, for each controller, you can use ExceptionHandler on a method that will be called when a given exception occurs. But this handles only those exceptions that occur within the controller in which it is defined. To overcome this problem, you can now use the ControllerAdvice annotation.

Thus, if you define the ExceptionHandler annotation on a method in a ControllerAdvice class, it will be applied to all the controllers. This annotation is used at the class level. The RestController annotation marks the class as a controller where every method returns a domain object instead of a view. By annotating a class with this annotation, you no longer need to add ResponseBody to all the RequestMapping methods.

It means that you no long use view-resolvers or send HTML in response. RestController is a convenience annotation that combines Controller and ResponseBody. This annotation is applied to Java classes.

This annotation is used along with the ExceptionHandler annotation to handle exceptions that occur within the controller. The SessionAttribute annotation is used to bind the method parameter to a session attribute. This annotation provides convenient access to the existing or permanent session attributes. This annotation is applied at the type level for a specific handler.

The SessionAtrributes annotation is used when you want to add a JavaBean object into a session. This is used when you want to keep the object in session for short-lived. SessionAttributes is used in conjunction with ModelAttribute. The ModelAttribute name is assigned to the SessionAttributes as a value. The SessionAttributes has two elements.

The value element is the name of the session in the model and the types element is the type of session attributes in the model. When developing a project with a number of services, you need to have a centralized and straightforward manner to configure and retrieve the configurations of all the services that you are going to develop. One problem that you may encounter while decomposing your application into microservices is that it becomes difficult for every service to know the address of every other service it depends on.

There comes the discovery service which is responsible for tracking the locations of all other microservices. In order to tell any application to register itself with Eureka, you just need to add the EnableDiscoveryClient annotation to the application entry point.

This annotation is applied to Java classes that can act as the circuit breaker. The circuit breaker pattern can allow a microservice to continue working when a related service fails, preventing the failure from cascading.

This also gives the failed service a time to recover. The class annotated with EnableCircuitBreaker will monitor, open, and close the circuit breaker.

When you apply the circuit breaker to a method, Hystrix watches for the failures of the method. Once failures build up to a threshold, Hystrix opens the circuit so that the subsequent calls also fail. Now, Hystrix redirects calls to the method, and they are passed to the specified fallback methods.

Hystrix looks for any method annotated with the HystrixCommand annotation and wraps it into a proxy connected to a circuit breaker so that Hystrix can monitor it. Here, HystrixCommand is applied to the original method bookList. The HystrixCommand annotation has newList as the fallback method. So, for some reason, if Hystrix opens the circuit on bookList , you will have a placeholder book list ready for the users. This annotation is placed before an interface definition, a method on an interface, a class definition, or a public method on a class.

The mere presence of Transactional is not enough to activate the transactional behavior. The Transactional is simply metadata that can be consumed by some runtime infrastructure.

This infrastructure uses the metadata to configure the appropriate beans with transactional behavior. This annotation is used on methods. The simplest way of enabling the cache behavior for a method is to annotate it with Cacheable and parameterize it with the name of the cache where the results would be stored. In the snippet above, the method getAddress is associated with the cache named addresses. Each time the method is called, the cache is checked to see whether the invocation has been already executed and does not have to be repeated.

Whenever you need to update the cache without interfering the method execution, you can use the CachePut annotation. That is, the method will always be executed and the result cached.

Using CachePut and Cacheable on the same method is strongly discouraged, as the former forces the execution in order to execute a cache update, the latter causes the method execution to be skipped by using the cache. It is not that you always want to populate the cache with more and more data.