![\"spring](\"http:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2019\/05\/SpringCoreAnnotations.png\")
<\/figure>\n<\/div>\nIn this tutorial, we\u2019ll explore all of these Spring Core annotations.<\/p>\n
DI-Related Annotations:<\/h3>\n1. @Autowired:<\/em><\/h3>\nWe use @Autowired<\/em> to mark the dependency which will be injected by the Spring container.<\/strong> It can be used with a constructor, setter or field-based injection.<\/p>\nConstructor Injection:<\/strong><\/p>\n\npublic class Employee {\n private Department dept;\n \n @Autowired\n public Employee(Department dept) {\n this.dept = dept;\n }\n}\n<\/pre>\nFor a constructor-based injection, all the constructor arguments are mandatory. Also Spring version 4.3<\/em> onwards, we can skip explicitly annotating the constructor with @Autowired<\/em> annotation unless we have two or more of them.<\/p>\nField Injection:<\/strong><\/p>\n\npublic class Employee {\n @Autowired\n private Department dept;\n}\n<\/pre>\nSetter Injection:<\/strong><\/p>\n\npublic class Employee {\n private Department dept;\n \n @Autowired\n public void setDept(Department dept) {\n this.dept = dept;\n }\n}\n<\/pre>\nThe @Autowired<\/em> annotation also takes in an optional boolean<\/em> argument named required<\/em>. By default, its value is set to true. <\/em>We can explicitly set it to false<\/em> for which Spring won\u2019t throw an exception when the auto-wiring fails.<\/p>\n2. @Qualifier:<\/em><\/h3>\nWe use @Qualifier<\/em> along with the @Autowired<\/em> annotation to avoid ambiguity when we have multiple beans of the same type.<\/strong><\/p>\nLet\u2019s say we have two classes:<\/p>\n
\n@Component\npublic class Employee implements Person {}\n \n@Component\npublic class Student implements Person {}\n<\/pre>\nSince both of them implements Person<\/em> interface, Spring has no means to know which Person <\/em>bean to inject when using @Autowired<\/em>. To resolve this issue, we can use @Qualifier<\/em> annotation:<\/p>\n\npublic class Main {\n \n @Autowired\n @Qualifier(\"employee\")\n private Person person;\n}\n<\/pre>\nJust like @Autowired<\/em>, we can use it with a setter, constructor or field-based injection.<\/p>\n3. @Primary:<\/em><\/h3>\nWe now know that we can use @Qualifier<\/em> along with @Autowired<\/em> when we have multiple beans of the same type. However, most of the time we\u2019ll specifically need one of those bean\u2019s instance and rarely the others. We can mark the<\/strong> most frequently used bean with @Primary<\/em> annotation. With it, all unqualified injections will resolve to our primary bean.<\/strong><\/p>\n\n@Primary\n@Component\npublic class Employee implements Person {}\n \n@Component\npublic class Student implements Person {}\n \n@Component\npublic class EmployeeHandler {\n \n @Autowired\n private Person employee; \n}\n \n@Component\npublic class StudentHandler {\n \n @Autowired\n @Qualifier(\"student\")\n private Person student; \n}\n<\/pre>\nSince we have given a qualifier in StudentHandler<\/em>, the Student<\/em> bean will be injected. For our EmployeeHandler<\/em>, we have skipped the qualifier and so an Employee<\/em> will be injected. This is so as Employee<\/em> is our primary bean of type Person<\/em>. <\/div> <\/div><\/p>\n4. @Bean:<\/em><\/h3>\n@Bean<\/em> is a method-level annotation used in @Configuration<\/em> class.<\/strong> It marks a factory method used to instantiate a Spring bean:<\/p>\n\n@Configuration\npublic class AppConfig {\n ...\n @Bean\n public Employee employee() {\n return new Employee();\n }\n}\n<\/pre>\nWhen a new instance of the return type is required, Spring will call these methods. The instantiated bean has the same name as that of the factory method. If we want to give it a different name, we can do so using the name argument of this annotation.<\/p>\n
\n@Bean(\"myEmp\")\npublic Employee employee() {\n return new Employee();\n}\n<\/pre>\n5. @Lazy:<\/em><\/h3>\nSpring, by default, instantiates all singleton beans at the time of application startup. If we want to prevent this eager initialization, we can use @Lazy<\/em> annotation. When we use @Lazy<\/em> annotation, the bean will be first instantiated on a user request.<\/p>\nWe can place this annotation on:<\/p>\n
\n- @Bean<\/em> annotated method to delay a specific bean instantiation<\/li>\n
- a class annotated with @Configuration<\/em> to delay creating all beans defined in this class<\/li>\n
- a class marked as @Component<\/em>, which will then lazy load<\/li>\n
- along with @Autowired<\/em> annotation over a constructor, field or a setter. Here as well, container will not load the injected dependency until we receive the first user request<\/li>\n<\/ul>\n
\n@Configuration\npublic class AppConfig {\n \n @Bean\n @Lazy\n public Employee employee() {\n return new Employee();\n }\n \n @Bean\n public Student student() {\n return new Student();\n }\n}\n<\/pre>\nIt also accepts an optional boolean<\/em> argument value <\/em>with a default set to true<\/em>. If we set it to false<\/em>, it will eagerly instantiate the bean. This can come handy when we have a Configuration<\/em> to load all beans lazily except a few.<\/p>\n6. @Required:<\/em><\/h3>\n@Required<\/em> is a method-level annotation used on setter methods of a bean. It simply marks the dependencies we want to populate using an XML:<\/strong><\/p>\n\n@Required\nvoid setName(String name) {\n this.name = name;\n}\n<\/pre>\n\n<bean class=\"com.programmergirl.spring.Employee\">\n <property name=\"name\" value=\"Joey\" \/>\n<\/bean>\n<\/pre>\nOn failing to do so, it will throw a BeanInitializationException<\/em>.<\/p>\n7. @Value:<\/em><\/h3>\nWe can use @Value<\/em> to inject property values defined in external sources into our beans.<\/strong> For instance, we can define a few properties in our application.yaml<\/em> or application.properties<\/em> file:<\/p>\n\njames.employee.id = 2563\n<\/pre>\nAnd then inject that value into our bean:<\/p>\n
\n@Value(\"${james.employee.id}\")\nprivate String jamesEmpId;\n<\/pre>\nWe can also use @Value<\/em> with SpEL.<\/p>\n8. @DependsOn:<\/em><\/h3>\nThe @DependsOn<\/em> annotation can force the Spring container to initialize one or more beans before the bean annotated with @DependsOn<\/em> annotation.<\/p>\nUsually, this behavior is automatic. We\u2019ll only need it when we have implicit dependencies, for example, loading a JDBC driver.<\/strong><\/p>\nWe can use @DependsOn<\/em> annotation on any class directly or indirectly annotated with @Component<\/em> or on factory methods annotated with @Bean<\/em>.<\/p>\n\n@Configuration\npublic class AppConfig {\n \n @Bean\n @DependsOn(value = {\"employee\"})\n public Dependent dependent() {\n return new Dependent();\n }\n \n}\n<\/pre>\n9. @Scope<\/em>:<\/h3>\nWe use @Scope<\/em> annotation to define the scope of a @Component<\/em> class or a @Bean<\/em> definition.<\/strong> It can be either singleton, prototype, request, session, globalSession<\/em> or some custom scope.<\/p>\n\n@Component\n@Scope(\"prototype\")\npublic class Employee {}\n<\/pre>\n10. @Lookup:<\/em><\/h3>\nA method annotated with @Lookup<\/em> tells Spring to return an instance of the method\u2019s return type when we invoke it. It\u2019s useful for:<\/p>\n\n- injecting a prototype bean into a singleton instance<\/li>\n
- procedurally injecting dependencies<\/li>\n<\/ul>\n
To learn how to inject a prototype bean into a singleton bean, please feel free to refer to this article.<\/a><\/p>\nContext Configuration Annotations:<\/h3>\n
We can configure our application context using the below annotations:<\/p>\n
1. @Profile:<\/em><\/h3>\nIf we want Spring to use a @Component<\/em> class or a @Bean<\/em> method only when a specific profile is active, we can mark it with @Profile<\/em> annotation.<\/strong> We can mention the name of the profile with the value<\/em> argument of this annotation:<\/p>\n\n@Component\n@Profile(\"dev\")\npublic class Employee {}\n<\/pre>\n2. @Import:<\/em><\/h3>\nUsing this annotation, we can specify one or more @Configuration<\/em> classes to import.<\/p>\n\n@Configuration\npublic class EmployeeConfig {\n \n @Bean\n public Employee employee() {\n return new Employee();\n }\n}\n \n@Configuration\n@Import(EmployeeConfig.class)\npublic class AppConfig {\n \n @Bean\n public Student student() {\n return new Student();\n }\n}\n<\/pre>\nWith this, we can just specify the AppConfig<\/em> class explicitly while initializing an application context. It will automatically import beans defined in our EmployeeConfig.<\/em><\/p>\n3. @ImportResource:<\/em><\/h3>\nWe can use this annotation to load beans into the ApplicationContext<\/em> from the applicationContext.xml<\/em> file<\/strong>:<\/p>\n\n@Configuration\n@ImportResource({\"classpath*:applicationContext.xml\"})\npublic class AppConfig {\n}\n<\/pre>\n4. @PropertySource:<\/em><\/h3>\nThis annotation provides a convenient way to define a property file to use for application settings:<\/p>\n
\n@Configuration\n@PropertySource(\"classpath:appConfig.properties\")\npublic class DatabaseConfig implements InitializingBean {\n \n @Autowired\n Environment env;\n \n ...\n \n void setDbConfig() {\n DataSourceConfig config = new DataSourceConfig();\n config.setDriver(env.getProperty(\"jdbc.driver\"));\n config.setUrl(env.getProperty(\"jdbc.url\"));\n config.setUsername(env.getProperty(\"jdbc.username\"));\n config.setPassword(env.getProperty(\"jdbc.password\"));\n }\n \n}\n<\/pre>\n5. @PropertySources:<\/em><\/h3>\nWe can use this annotation to specify multiple @PropertySource <\/em>configurations:<\/p>\n\n@Configuration\n@PropertySources({ \n @PropertySource(\"classpath:\/student.properties\"),\n @PropertySource(\"classpath:\/employee.properties\"),\n @PropertySource(\"classpath:\/database.properties\")\n})\nclass AppConfig {}\n<\/pre>\nJava 8 onwards, we can achieve the same with just using repeated annotation feature i.e. directly specifying multiple @PropertySource<\/em> annotations.<\/strong><\/p>\nConclusion:<\/h3>\n
In this article, we covered the most common Spring core annotations. We can use them either for bean wiring or configuring an application context.<\/p>\n
\n
We use @Autowired<\/em> to mark the dependency which will be injected by the Spring container.<\/strong> It can be used with a constructor, setter or field-based injection.<\/p>\n Constructor Injection:<\/strong><\/p>\n For a constructor-based injection, all the constructor arguments are mandatory. Also Spring version 4.3<\/em> onwards, we can skip explicitly annotating the constructor with @Autowired<\/em> annotation unless we have two or more of them.<\/p>\n Field Injection:<\/strong><\/p>\n Setter Injection:<\/strong><\/p>\n The @Autowired<\/em> annotation also takes in an optional boolean<\/em> argument named required<\/em>. By default, its value is set to true. <\/em>We can explicitly set it to false<\/em> for which Spring won\u2019t throw an exception when the auto-wiring fails.<\/p>\n We use @Qualifier<\/em> along with the @Autowired<\/em> annotation to avoid ambiguity when we have multiple beans of the same type.<\/strong><\/p>\n Let\u2019s say we have two classes:<\/p>\n Since both of them implements Person<\/em> interface, Spring has no means to know which Person <\/em>bean to inject when using @Autowired<\/em>. To resolve this issue, we can use @Qualifier<\/em> annotation:<\/p>\n Just like @Autowired<\/em>, we can use it with a setter, constructor or field-based injection.<\/p>\n We now know that we can use @Qualifier<\/em> along with @Autowired<\/em> when we have multiple beans of the same type. However, most of the time we\u2019ll specifically need one of those bean\u2019s instance and rarely the others. We can mark the<\/strong> most frequently used bean with @Primary<\/em> annotation. With it, all unqualified injections will resolve to our primary bean.<\/strong><\/p>\n Since we have given a qualifier in StudentHandler<\/em>, the Student<\/em> bean will be injected. For our EmployeeHandler<\/em>, we have skipped the qualifier and so an Employee<\/em> will be injected. This is so as Employee<\/em> is our primary bean of type Person<\/em>. @Bean<\/em> is a method-level annotation used in @Configuration<\/em> class.<\/strong> It marks a factory method used to instantiate a Spring bean:<\/p>\n When a new instance of the return type is required, Spring will call these methods. The instantiated bean has the same name as that of the factory method. If we want to give it a different name, we can do so using the name argument of this annotation.<\/p>\n Spring, by default, instantiates all singleton beans at the time of application startup. If we want to prevent this eager initialization, we can use @Lazy<\/em> annotation. When we use @Lazy<\/em> annotation, the bean will be first instantiated on a user request.<\/p>\n We can place this annotation on:<\/p>\n It also accepts an optional boolean<\/em> argument value <\/em>with a default set to true<\/em>. If we set it to false<\/em>, it will eagerly instantiate the bean. This can come handy when we have a Configuration<\/em> to load all beans lazily except a few.<\/p>\n @Required<\/em> is a method-level annotation used on setter methods of a bean. It simply marks the dependencies we want to populate using an XML:<\/strong><\/p>\n On failing to do so, it will throw a BeanInitializationException<\/em>.<\/p>\n We can use @Value<\/em> to inject property values defined in external sources into our beans.<\/strong> For instance, we can define a few properties in our application.yaml<\/em> or application.properties<\/em> file:<\/p>\n And then inject that value into our bean:<\/p>\n We can also use @Value<\/em> with SpEL.<\/p>\n The @DependsOn<\/em> annotation can force the Spring container to initialize one or more beans before the bean annotated with @DependsOn<\/em> annotation.<\/p>\n Usually, this behavior is automatic. We\u2019ll only need it when we have implicit dependencies, for example, loading a JDBC driver.<\/strong><\/p>\n We can use @DependsOn<\/em> annotation on any class directly or indirectly annotated with @Component<\/em> or on factory methods annotated with @Bean<\/em>.<\/p>\n We use @Scope<\/em> annotation to define the scope of a @Component<\/em> class or a @Bean<\/em> definition.<\/strong> It can be either singleton, prototype, request, session, globalSession<\/em> or some custom scope.<\/p>\n A method annotated with @Lookup<\/em> tells Spring to return an instance of the method\u2019s return type when we invoke it. It\u2019s useful for:<\/p>\n To learn how to inject a prototype bean into a singleton bean, please feel free to refer to this article.<\/a><\/p>\n We can configure our application context using the below annotations:<\/p>\n If we want Spring to use a @Component<\/em> class or a @Bean<\/em> method only when a specific profile is active, we can mark it with @Profile<\/em> annotation.<\/strong> We can mention the name of the profile with the value<\/em> argument of this annotation:<\/p>\n Using this annotation, we can specify one or more @Configuration<\/em> classes to import.<\/p>\n With this, we can just specify the AppConfig<\/em> class explicitly while initializing an application context. It will automatically import beans defined in our EmployeeConfig.<\/em><\/p>\n We can use this annotation to load beans into the ApplicationContext<\/em> from the applicationContext.xml<\/em> file<\/strong>:<\/p>\n This annotation provides a convenient way to define a property file to use for application settings:<\/p>\n We can use this annotation to specify multiple @PropertySource <\/em>configurations:<\/p>\n Java 8 onwards, we can achieve the same with just using repeated annotation feature i.e. directly specifying multiple @PropertySource<\/em> annotations.<\/strong><\/p>\n In this article, we covered the most common Spring core annotations. We can use them either for bean wiring or configuring an application context.<\/p>\n\npublic class Employee {\n private Department dept;\n \n @Autowired\n public Employee(Department dept) {\n this.dept = dept;\n }\n}\n<\/pre>\n\npublic class Employee {\n @Autowired\n private Department dept;\n}\n<\/pre>\n\npublic class Employee {\n private Department dept;\n \n @Autowired\n public void setDept(Department dept) {\n this.dept = dept;\n }\n}\n<\/pre>\n2. @Qualifier:<\/em><\/h3>\n
\n@Component\npublic class Employee implements Person {}\n \n@Component\npublic class Student implements Person {}\n<\/pre>\n\npublic class Main {\n \n @Autowired\n @Qualifier(\"employee\")\n private Person person;\n}\n<\/pre>\n3. @Primary:<\/em><\/h3>\n
\n@Primary\n@Component\npublic class Employee implements Person {}\n \n@Component\npublic class Student implements Person {}\n \n@Component\npublic class EmployeeHandler {\n \n @Autowired\n private Person employee; \n}\n \n@Component\npublic class StudentHandler {\n \n @Autowired\n @Qualifier(\"student\")\n private Person student; \n}\n<\/pre>\n4. @Bean:<\/em><\/h3>\n
\n@Configuration\npublic class AppConfig {\n ...\n @Bean\n public Employee employee() {\n return new Employee();\n }\n}\n<\/pre>\n\n@Bean(\"myEmp\")\npublic Employee employee() {\n return new Employee();\n}\n<\/pre>\n5. @Lazy:<\/em><\/h3>\n
\n
\n@Configuration\npublic class AppConfig {\n \n @Bean\n @Lazy\n public Employee employee() {\n return new Employee();\n }\n \n @Bean\n public Student student() {\n return new Student();\n }\n}\n<\/pre>\n6. @Required:<\/em><\/h3>\n
\n@Required\nvoid setName(String name) {\n this.name = name;\n}\n<\/pre>\n\n<bean class=\"com.programmergirl.spring.Employee\">\n <property name=\"name\" value=\"Joey\" \/>\n<\/bean>\n<\/pre>\n
7. @Value:<\/em><\/h3>\n
\njames.employee.id = 2563\n<\/pre>\n
\n@Value(\"${james.employee.id}\")\nprivate String jamesEmpId;\n<\/pre>\n8. @DependsOn:<\/em><\/h3>\n
\n@Configuration\npublic class AppConfig {\n \n @Bean\n @DependsOn(value = {\"employee\"})\n public Dependent dependent() {\n return new Dependent();\n }\n \n}\n<\/pre>\n9. @Scope<\/em>:<\/h3>\n
\n@Component\n@Scope(\"prototype\")\npublic class Employee {}\n<\/pre>\n10. @Lookup:<\/em><\/h3>\n
\n
Context Configuration Annotations:<\/h3>\n
1. @Profile:<\/em><\/h3>\n
\n@Component\n@Profile(\"dev\")\npublic class Employee {}\n<\/pre>\n2. @Import:<\/em><\/h3>\n
\n@Configuration\npublic class EmployeeConfig {\n \n @Bean\n public Employee employee() {\n return new Employee();\n }\n}\n \n@Configuration\n@Import(EmployeeConfig.class)\npublic class AppConfig {\n \n @Bean\n public Student student() {\n return new Student();\n }\n}\n<\/pre>\n3. @ImportResource:<\/em><\/h3>\n
\n@Configuration\n@ImportResource({\"classpath*:applicationContext.xml\"})\npublic class AppConfig {\n}\n<\/pre>\n4. @PropertySource:<\/em><\/h3>\n
\n@Configuration\n@PropertySource(\"classpath:appConfig.properties\")\npublic class DatabaseConfig implements InitializingBean {\n \n @Autowired\n Environment env;\n \n ...\n \n void setDbConfig() {\n DataSourceConfig config = new DataSourceConfig();\n config.setDriver(env.getProperty(\"jdbc.driver\"));\n config.setUrl(env.getProperty(\"jdbc.url\"));\n config.setUsername(env.getProperty(\"jdbc.username\"));\n config.setPassword(env.getProperty(\"jdbc.password\"));\n }\n \n}\n<\/pre>\n5. @PropertySources:<\/em><\/h3>\n
\n@Configuration\n@PropertySources({ \n @PropertySource(\"classpath:\/student.properties\"),\n @PropertySource(\"classpath:\/employee.properties\"),\n @PropertySource(\"classpath:\/database.properties\")\n})\nclass AppConfig {}\n<\/pre>\nConclusion:<\/h3>\n