Why do we need to use #Component annotation for Filter in spring boot, why we can't use #Configuration annotation.
Please note: I am not trying to register filter in FilterRegistrationBean.
#Configuration indicates that the class may contain #Bean methods and should be processed to define those beans in the application context. This isn't something that a Filter does so it should not be annotated with #Configuration.
If you look at the source for #Configuration, you'll see that it's annotated with #Component. #Configuration is a special kinds of #Component. In this case, all you need is for the Filter itself to be a bean. It doesn't have any #Bean methods so it's sufficient for it to be annotated with #Component. This will ensure that the Filter is a bean and Spring Boot will the register the Filter bean with the servlet container without any need for a FilterRegistrationBean and without wasting resources unnecessarily processing your Filter's class looking for #Bean methods.
Related
I know that we used #Service for the business logic, but what exactly Spring do when he sees this annotation? Can someone please exaplain it, if possible with the example. F.ex when we write #Autoweired, it allows Spring to resolve and inject collaborating beans into our bean. Thanks In advance
There is no difference at all as far as I know.
You can use #Component annotation as well on your service class and it will work fine. Spring will recognize and scan that for bean creation.
#Service annotation contains #Component in it, similar to the fact that #RestController has #Controller as part of it, but in controller theory, #RestController does bring some additional features ( #Controller + #ResponseBody = #RestController ).
Overall it's just good practice to annotate service classes with #Service, and persistence classes with #Repository ( #Repository does have additional features over #Component like transaction rollback ), but all these stereotype annotations contain #Component annotation for Spring to be able to scan them and register in Spring container for bean creation.
In my opinion, #Service is just used to make your code more readable and structured, but makes no difference if you would use #Component for your Service layer.
I tried to use #PropertySource in a #Component like:
#Component
#PropertySource("somepropertiesfile.properties")
public class Student {
...
}
It worked fine.
I want to understand, what is the different between using #PropertySource with #Component and #PropertySource with #Configuration.
Is there any difference or impact of using #PropertySource with #Component.
Configuration is itself a Component type, look into the #Configuration annotation implementation below.
#Target(ElementType.TYPE)
#Retention(RetentionPolicy.RUNTIME)
#Documented
#Component
public #interface Configuration {
}
From API
Component: Indicates that an annotated class is a "component". Such classes are considered as candidates for auto-detection when using annotation-based configuration and classpath scanning.
Configuration: Indicates that a class declares one or more #Bean methods and may be processed by the Spring container to generate bean definitions and service requests for those beans at runtime.
The #Bean annotation is used to indicate that a method instantiates, configures and initializes a new object to be managed by the Spring IoC container. These are same as Spring’s XML configuration. You can use #Bean annotated methods with any Spring #Component, however, they are most often used with #Configuration beans.
Here also you can use #PropertySource in #Component class but these are most suitable for #Configuration classes as it is a configuration related task.
You can refer Doc for detailed information.
I recently started exploring Spring Boot. I see that there are 2 ways to define Beans in Spring Boot.
Define #Bean in the class annotated with #SprinBootApplication
Define #Bean in a class annotated with #Configuration
I am also confused about stereo-type annotation #Repository #Service #Controller etc.
Can someone please explain how dependency-injection works with these annotations?
Yes it is possible.
Either you use #Bean in any of your #Configuration or #SpringBootApplication class or mark the bean classes explicitly with annotations like #Service, #Component #Repository etc.
#Service or #Component
When you mark a class with #Service or #Compoenent and if spring's annotation scanning scope allows it to reach to the package, spring will register the instances of those classes as spring beans.
You can provide the packages to be included/excluded during scan with #ComponentScan
#Bean
#Beans are marked on factory methods which can create an instance of a particular class.
#Bean
public Account getAccount(){
return new DailyAccount();
}
Now in you application you can simply #Autowire Account and spring will internally call its factory method getAccount, which in turn returns an instance of DailyAccount.
There is a simple difference of using #Bean vs #Service or #Compoenent.
The first one makes your beans loosely coupled to each other.
In the #Bean, you have flexibility to change the account implementation without even changing any of the account classes.
Consider if your classes instantiation is a multi-step operation like read properties values etc then you can easily do it in your #Bean method.
#Bean also helps if you don't have source code access to the class you are trying to instantiate.
Spring Boot auto-configuration attempts to automatically configure your Spring application based on the jar dependencies that you have added.
You need to opt-in to auto-configuration by adding the #EnableAutoConfiguration or #SpringBootApplication annotations to one of your #Configuration classes.
You are free to use any of the standard Spring Framework techniques to define your beans and their injected dependencies. For simplicity, we often find that using #ComponentScan (to find your beans) and using #Autowired (to do constructor injection) works well.
One way is to define #Bean in the class annotated with
#SprinBootApplication
If you see #SprinBootApplication it is combination of many annotation, and one of them is #Configuration. So when you define #Bean in the Main class, it means it's inside #Configuration class.
According to Configuration docs :
Indicates that a class declares one or more #Bean methods and may be
processed by the Spring container to generate bean definitions and
service requests for those beans at runtime.
class annotated with #Configuration
When you define #Bean is a class annotated with #Configuration class, it means it is the part of spring configuration all the Beans define in it all available for Dependency-Injection.
I have also seen some code where neither of the 2 above approaches
have been used and yet dependency injection works fine. I have tried
to research a lot on this but could not find any concrete answer to
this. Is this possible?
I am assuming you are talking about Sterio-type annotation. Every sterio type annotation has #Component, according to docs :
Indicates that an annotated class is a "component". Such classes are
considered as candidates for auto-detection when using
annotation-based configuration and classpath scanning.
I seems have problem understanding these 2 annotation. I have try to read the javadocs but still cannot figure out. Can anyone help to explain with simple code about these 2 ?
Thank so much in advance.
You use #Configuration as a replacement to the XML based configuration for configuring spring beans. So instead of an xml file we write a class and annotate that with #Configuration and define the beans in it using #Bean annotation on the methods.
And finally you use AnnotationConfigApplicationContext to register this #Configuration class and thus spring manages the beans defined. Small example you can find at Spring Configuration Documentaion.
Quoting from the above link
It is just another way of configuration Indicates that a class declares
one or more #Bean methods and may be processed by the Spring container
to generate bean definitions and service requests for those beans at
runtime.
And #Configurable is an annotation that injects dependencies into objects that are not managed by Spring using aspectj libraries. i.e., you still use old way of instantiation with plain new operator to create objects but the spring will take care of injecting the dependencies into that object automatically for you.
#Configuration is the heart of the Java-based configuration mechanism and provides an alternative to XML-based configuration.
#Configuration classes are just like regular #Components classes, except that methods annotated with #Bean are used to factory beans.
In what order the #Component classes will be created in spring. is it #configuration annotated class that will be created first ?? Can we specify the order of creation ??
#Component and #Configuration are different types of annotations.
#Component and similar annotations (#Service, #Repository, etc. ) and its JSR-330 counterpart and allow you to declare beans that are to be picked up by autoscanning with <context:component-scan/> or #ComponentScan they register the bean definition for the classes, so they are roughly equivalent to declaring the specified beans with the <bean ... /> tag in XML. This bean types will adhere to the standard proxy creation policies.
#Configuration annotation was designed as the replacement of the XML configuration file. To create #Configuration annotated beans, Spring will always use CGLIB to subclass the #Configuration annotated class, overriding its #Bean annotated method to replace it with the bean lookup method to make singleton beans to be created only once. Despite that, #Configuration annotated classes are still able to use annotated(#Autowired, #Inject etc.) fields and properties to request beans (and even other #Configuration annotated beans too) from the container.
Now answer to your question, you have to annotate the class with #Configuration and then with #ComponentScan(basePackages = { "com.test.*" }) and you can't specify the order of creation.