【备注】附件中是该文章的PDF压缩文件。
============ 精简版
@Autowired
We can use the @Autowired annotation to mark the dependency that Spring is going to resolve and inject. We can use this annotation with a constructor, setter, or field injection.
Constructor Injection:
@RestController
public class CustomerController {
private CustomerService customerService;
@Autowired
public CustomerController(CustomerService customerService) {
this.customerService = customerService;
}
}
Setter Injection:
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class CustomerController {
private CustomerService customerService;
@Autowired
public void setCustomerService(CustomerService customerService) {
this.customerService = customerService;
}
}
Field Injection:
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class CustomerController {
@Autowired
private CustomerService customerService;
}
@Bean
- @Bean is a method-level annotation and a direct analog of the XML element. The annotation supports some of the attributes offered by, such as the init-method, destroy-method, auto-wiring, and name.
- You can use the @Bean annotation in a @Configuration-annotated or @Component-annotated class.
The following is a simple example of an @Bean method declaration:
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.companyname.projectname.customer.CustomerService;
import com.companyname.projectname.order.OrderService;
@Configuration
public class Application {
@Bean
public CustomerService customerService() {
return new CustomerService();
}
@Bean
public OrderService orderService() {
return new OrderService();
}
}
The preceding configuration is equivalent to the following Spring XML:
<beans>
<bean id="customerService" class="com.companyname.projectname.CustomerService"/>
<bean id="orderService" class="com.companyname.projectname.OrderService"/>
</beans>
@Qualifier
This annotation helps fine-tune annotation-based auto-wiring. There may be scenarios when we create more than one bean of the same type and want to wire only one of them with a property. This can be controlled using the @Qualifier annotation along with the @Autowired annotation.
Example: Consider the EmailService and SMSService classes to implement the single MessageService interface.
Create the MessageService interface for multiple message service implementations.
public interface MessageService {
public void sendMsg(String message);
}
Next, create implementations: EmailService and SMSService.
public class EmailService implements MessageService{
public void sendMsg(String message) {
System.out.println(message);
}
}
public class SMSService implements MessageService{
public void sendMsg(String message) {
System.out.println(message);
}
}
It's time to see the usage of the @Qualifier annotation.
public interface MessageProcessor {
public void processMsg(String message);
}
public class MessageProcessorImpl implements MessageProcessor {
private MessageService messageService;
// setter based DI
@Autowired
@Qualifier("emailService")
public void setMessageService(MessageService messageService) {
this.messageService = messageService;
}
// constructor based DI
@Autowired
public MessageProcessorImpl(@Qualifier("emailService") MessageService messageService) {
this.messageService = messageService;
}
public void processMsg(String message) {
messageService.sendMsg(message);
}
}
@Required
The @Required annotation is a method-level annotation and applied to the setter method of a bean.
This annotation simply indicates that the setter method must be configured to be dependency-injected with a value at configuration time.
For example, @Required on setter methods marks dependencies that we want to populate through XML:
@Required
void setColor(String color) {
this.color = color;
}
<bean class="com.javaguides.spring.Car">
<property name="color" value="green" />
</bean>
Otherwise, the BeanInitializationException will be thrown.
@Value
The Spring @Value annotation is used to assign default values to variables and method arguments. We can read Spring environment variables as well as system variables using the @Value annotation.
The Spring @Value annotation also supports SpEL. Let’s look at some of the examples of using the @Value annotation.
Examples: We can assign a default value to a class property using the @Value annotation.
@Value("Default DBConfiguration")
private String defaultName;
The @Value annotation argument can be a string only, but Spring tries to convert it to the specified type. The following code will work fine and assign the boolean and integer values to the variable.
@Value("true")
private boolean defaultBoolean;
@Value("10")
private int defaultInt;
This demonstrates the Spring @Value — Spring Environment Property
@Value("${APP_NAME_NOT_FOUND}")
private String defaultAppName;
Next, assign system variables using the @Value annotation.
@Value("${java.home}")
private String javaHome;
@Value("${HOME}")
private String homeDir;
Spring @Value – SpEL
@Value("#{systemProperties['java.home']}")
private String javaHome;
@DependsOn
The@DependsOn annotation can force Spring IoC containers to initialize one or more beans before the bean, which is annotated by the @DependsOn annotation.
The @DependsOn annotation may be used on any class directly or indirectly annotated with the @Component or on methods annotated with the @Bean.
Example: Let's create FirstBean and SecondBean classes. In this example, the SecondBean is initialized before bean FirstBean.
public class FirstBean {
@Autowired
private SecondBean secondBean;
}
public class SecondBean {
public SecondBean() {
System.out.println("SecondBean Initialized via Constuctor");
}
}
Declare the above beans in Java based on the configuration class.
@Configuration
public class AppConfig {
@Bean("firstBean")
@DependsOn(value = {
"secondBean"
})
public FirstBean firstBean() {
return new FirstBean();
}
@Bean("secondBean")
public SecondBean secondBean() {
return new SecondBean();
}
}
@Lazy
By default, the Spring IoC container creates and initializes all singleton beans at the time of application startup. We can prevent this pre-initialization of a singleton bean by using the @Lazy annotation.
The @Lazy annotation may be used on any class, directly or indirectly annotated with the @Component or on methods annotated with the @Bean.
Example: Consider we have below two beans — FirstBean and SecondBean. In this example, we will explicitly load FirstBean using the @Lazyannotation.
public class FirstBean {
public void test() {
System.out.println("Method of FirstBean Class");
}
}
public class SecondBean {
public void test() {
System.out.println("Method of SecondBean Class");
}
}
Declare the above beans in Java based on the configuration class.
@Configuration
public class AppConfig {
@Lazy(value = true)
@Bean
public FirstBean firstBean() {
return new FirstBean();
}
@Bean
public SecondBean secondBean() {
return new SecondBean();
}
}
As we can see, bean secondBean is initialized by the Spring container, while the bean firstBean is initialized explicitly.
@Lookup
A method annotated with @Lookup tells Spring to return an instance of the method’s return type when we invoke it.
@Primary
We use the @Primary to give higher preference to a bean when there are multiple beans of the same type.
@Component
@Primary
class Car implements Vehicle {}
@Component
class Bike implements Vehicle {}
@Component
class Driver {
@Autowired
Vehicle vehicle;
}
@Component
class Biker {
@Autowired
@Qualifier("bike")
Vehicle vehicle;
}
@Scope
We use the@Scope annotation to define the scope of a @Component class or the @Bean definition. It can be either singleton, prototype, request, session, globalSession, or some custom scope.
For example:
@Component
@Scope(value = ConfigurableBeanFactory.SCOPE_SINGLETON)
public class TwitterMessageService implements MessageService {
}
@Component
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public class TwitterMessageService implements MessageService {
}
@Profile
If we want Spring to use the @Component class or the @Bean method only when a specific profile is active, we can mark it with @Profile. We can configure the name of the profile with the value argument of the annotation:
@Component
@Profile("sportDay")
class Bike implements Vehicle {}
@Import
The @Import annotation indicates one or more @Configuration classes to import.
For example: in a Java-based configuration, Spring provides the @Import annotation, which allows the loading @Bean definitions from another configuration class.
@Configuration
public class ConfigA {
@Bean
public A a() {
return new A();
}
}
@Configuration
@Import(ConfigA.class)
public class ConfigB {
@Bean
public B b() {
return new B();
}
}
Now, rather than needing to specify both the ConfigA class and ConfigB class when instantiating the context, only ConfigB needs to be supplied explicitly.
@ImportResource
Spring provides an @ImportResource annotation used to load beans from an applicationContext.xml file into an ApplicationContext. For example: consider that we have applicationContext.xml Spring bean configuration XML file on the classpath.
@Configuration
@ImportResource({"classpath*:applicationContext.xml"})
public class XmlConfiguration {
}
@PropertySource
The @PropertySource annotation provides a convenient and declarative mechanism for adding a PropertySource to Spring’s Eenvironment to be used in conjunction with the @Configuration classes.
For example, we are reading database configuration from the file config.propertiesfile and setting these property values to the DataSourceConfig class using the Environment.
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
@Configuration
@PropertySource("classpath:config.properties")
public class ProperySourceDemo implements InitializingBean {
@Autowired
Environment env;
@Override
public void afterPropertiesSet() throws Exception {
setDatabaseConfig();
}
private void setDatabaseConfig() {
DataSourceConfig config = new DataSourceConfig();
config.setDriver(env.getProperty("jdbc.driver"));
config.setUrl(env.getProperty("jdbc.url"));
config.setUsername(env.getProperty("jdbc.username"));
config.setPassword(env.getProperty("jdbc.password"));
System.out.println(config.toString());
}
}
@PropertySources
We can use this annotation to specify multiple @PropertySource configurations:
@PropertySources({
@PropertySource("classpath:config.properties"),
@PropertySource("classpath:db.properties")
})
public class AppConfig {
//...
}
============ 原文
As we know, Spring DI and Spring IOC are core concepts of the Spring Framework. Let's explore some Spring core annotations from the org.springframework.beans.factory.annotation and org.springframework.context.annotation packages.
We often call these “Spring core annotations,” and we’ll review them in this article.
Here's a list of all known Spring core annotations.
@Autowired
We can use the @Autowired annotation to mark the dependency that Spring is going to resolve and inject. We can use this annotation with a constructor, setter, or field injection.
Constructor Injection:
Setter Injection:
Field Injection:
For more details, visit our articles about @Autowired and Guide to Dependency Injection in Spring.
@Bean
-
@Beanis a method-level annotation and a direct analog of the XML element. The annotation supports some of the attributes offered by, such as the init-method, destroy-method, auto-wiring, and name. - You can use the
@Beanannotation in a@Configuration-annotated or@Component-annotated class.
The following is a simple example of an @Bean method declaration:
The preceding configuration is equivalent to the following Spring XML:
Read more about the @Bean annotation in this article Spring @Bean Annotation with Example.
@Qualifier
This annotation helps fine-tune annotation-based auto-wiring. There may be scenarios when we create more than one bean of the same type and want to wire only one of them with a property. This can be controlled using the @Qualifier annotation along with the @Autowired annotation.
Example: Consider the EmailService and SMSService classes to implement the single MessageService interface.
Create the MessageService interface for multiple message service implementations.
Next, create implementations: EmailService and SMSService.
It's time to see the usage of the @Qualifier annotation.
Read more about this annotation in this article: Spring @Qualifier Annotation Example.
@Required
The @Required annotation is a method-level annotation and applied to the setter method of a bean.
This annotation simply indicates that the setter method must be configured to be dependency-injected with a value at configuration time.
For example, @Required on setter methods marks dependencies that we want to populate through XML:
Otherwise, the BeanInitializationException will be thrown.
@Value
The Spring @Value annotation is used to assign default values to variables and method arguments. We can read Spring environment variables as well as system variables using the @Value annotation.
The Spring @Value annotation also supports SpEL. Let’s look at some of the examples of using the @Value annotation.
Examples: We can assign a default value to a class property using the @Value annotation.
The @Value annotation argument can be a string only, but Spring tries to convert it to the specified type. The following code will work fine and assign the boolean and integer values to the variable.
This demonstrates the Spring @Value — Spring Environment Property
Next, assign system variables using the @Value annotation.
Spring @Value – SpEL
@DependsOn
The@DependsOn annotation can force Spring IoC containers to initialize one or more beans before the bean, which is annotated by the @DependsOn annotation.
The @DependsOn annotation may be used on any class directly or indirectly annotated with the @Component or on methods annotated with the @Bean.
Example: Let's create FirstBean and SecondBean classes. In this example, the SecondBean is initialized before bean FirstBean.
Declare the above beans in Java based on the configuration class.
Read more about @DependsOn annotation on Spring - @DependsOn Annotation Example.
@Lazy
By default, the Spring IoC container creates and initializes all singleton beans at the time of application startup. We can prevent this pre-initialization of a singleton bean by using the @Lazy annotation.
The @Lazy annotation may be used on any class, directly or indirectly annotated with the @Component or on methods annotated with the @Bean.
Example: Consider we have below two beans — FirstBean and SecondBean. In this example, we will explicitly load FirstBean using the @Lazyannotation.
Declare the above beans in Java based on the configuration class.
As we can see, bean secondBean is initialized by the Spring container, while the bean firstBean is initialized explicitly.
Read more about the @Lazy annotation with a complete example on Spring - @Lazy Annotation Example.
@Lookup
A method annotated with @Lookup tells Spring to return an instance of the method’s return type when we invoke it.
Detailed information about this annotation can be found on Spring @LookUp Annotation.
@Primary
We use the @Primary to give higher preference to a bean when there are multiple beans of the same type.
Read more about this annotation on Spring - @Primary Annotation Example.
@Scope
We use the@Scope annotation to define the scope of a @Component class or the @Bean definition. It can be either singleton, prototype, request, session, globalSession, or some custom scope.
For example:
Read more about the @Scope annotations on Spring @Scope annotation with Singleton Scope Exampleand Spring @Scope annotation with Prototype Scope Example.
@Profile
If we want Spring to use the @Component class or the @Bean method only when a specific profile is active, we can mark it with @Profile. We can configure the name of the profile with the value argument of the annotation:
You can read more about profiles in this Spring Profiles.
@Import
The @Import annotation indicates one or more @Configuration classes to import.
For example: in a Java-based configuration, Spring provides the @Import annotation, which allows the loading @Bean definitions from another configuration class.
Now, rather than needing to specify both the ConfigA class and ConfigB class when instantiating the context, only ConfigB needs to be supplied explicitly.
Read more about the @Import annotation on Spring @Import Annotation.
@ImportResource
Spring provides an @ImportResource annotation used to load beans from an applicationContext.xml file into an ApplicationContext. For example: consider that we have applicationContext.xml Spring bean configuration XML file on the classpath.
Read more about this annotation with a complete example on Spring @ImportResource Annotation.
@PropertySource
The @PropertySource annotation provides a convenient and declarative mechanism for adding a PropertySource to Spring’s Eenvironment to be used in conjunction with the @Configuration classes.
For example, we are reading database configuration from the file config.propertiesfile and setting these property values to the DataSourceConfig class using the Environment.
Read more about this annotation on Spring @PropertySource Annotation with Example.
@PropertySources
We can use this annotation to specify multiple @PropertySource configurations:
Read more about this annotation on Spring @PropertySources Annotation.
Hope you enjoyed this post on the best Spring annotations for your project! Happy coding!
相关推荐
Spring MVC Annotation验证方法 Spring MVC 框架提供了多种验证方法，其中一种常用的方式是使用Annotation验证。本文将详细介绍 Spring MVC Annotation验证的方法，包括使用 Spring MVC 自带的 Annotation 验证和...
在本资料"Spring_Annotation_AOP"中，我们将深入探讨Spring框架如何利用注解实现AOP，以及其背后的原理和实践应用。 面向切面编程（AOP）是一种编程范式，旨在提高代码的可维护性和可重用性，通过将关注点分离，...
### Spring的Annotation方式详解 #### 引言 随着Spring框架的发展，其依赖注入（DI）机制也经历了从XML配置向注解驱动的重大转变。自Spring 3.0版本起，框架引入了一系列注解来简化依赖配置，使得开发人员能够在不...
### Spring框架中的Annotation注解详解 #### 一、Spring与Annotation的基本概念 Spring框架通过引入Annotation，极大地简化了Java开发中的依赖注入(Dependency Injection, DI)和面向切面编程(AOP)的过程。...
在Spring框架中，Annotation配置是一种简洁且强大的方式来管理Bean的定义和依赖注入，它消除了传统的XML配置文件，使得代码更加简洁、易读。在Spring 3.0及以上版本中，Annotation配置得到了广泛的应用。 首先，...
【Spring Annotation简介一】 在Java开发领域，Spring框架以其强大的功能和灵活性深受广大开发者喜爱。Spring Annotation是Spring框架中的一个重要特性，它极大地简化了配置，提高了代码的可读性和可维护性。这篇...
在Java Web开发中，Spring和MyBatis是两个非常重要的框架。Spring是一个全面的后端开发框架，提供了依赖注入、AOP（面向切面编程）、事务管理等功能；而MyBatis则是一个轻量级的持久层框架，它将SQL与Java代码分离，...
Spring框架是Java开发中不可或缺的一部分，它通过提供丰富的注解简化了依赖注入、配置管理和AOP（面向切面编程）等任务。本文将深入探讨Spring注解及其在实际开发中的应用。 1. **依赖注入（Dependency Injection, ...
Annotation注入是Spring IOC的一种实现方式，它利用Java注解替代XML配置来管理Bean的依赖关系，使得代码更加简洁、可读性更强。 在Spring框架中，我们主要关注以下几个关键的注解： 1. `@Component`：这是一个基础...
Spring 的 Annotation-Driven 配置事务管理器详解（多数据源配置） Spring 框架提供了强大的事务管理机制，通过使用 Annotation-Driven 配置，可以方便地管理事务。在多数据源配置中，spring 的 Annotation-Driven...
Spring Annotation 注解 Spring 框架中的注解是用于在 Java 类中添加元数据的，通过这些元数据，Spring 框架可以在运行时提供更多的功能。 Spring 框架提供了多种类型的注解，例如 @Autowired、@Resource、@...
技术分享：详解Spring基于Annotation的依赖注入实现
这里主要讨论的是如何将这三者结合，并利用注解（Annotation）进行配置，以简化开发过程。 Struts2是MVC（模型-视图-控制器）框架，主要负责处理HTTP请求和控制应用的流程。它通过Action类处理业务逻辑，使用拦截器...
在IT行业中，Spring框架是Java开发中的核心工具之一，它为开发者提供了许多强大的功能，包括依赖注入、面向切面编程（AOP）等。本文将深入探讨如何利用Spring的注解式AOP和反射机制来实现日志记录，以便更好地理解和...
本篇主要聚焦于"Spring 常用 Transaction Annotation"，即声明式事务管理，这是一种更简洁、易于维护的事务控制方式。 首先，Spring的声明式事务管理基于AOP（面向切面编程），它允许我们在不修改业务代码的情况下...
在IT行业中，SpringMVC、Spring和MyBatis是三个非常重要的Java开发框架，它们各自在Web应用的各个层面上发挥着关键作用。本项目是一个整合了这三个框架的基于Annotation和Maven的项目，旨在提供一种高效、灵活的开发...
spring-boot-mybaits-annotation：注解版本 spring-boot-mybaits-xml：xml配置版本 spring-boot-mybatis-mulidatasource：springboot+mybatis多数据源最简解决方案 spring-boot-mybatis-annotation-...
在Spring框架中，注解（Annotation）自动匹配注入IoC（Inversion of Control，控制反转）是一种关键特性，它极大地简化了Java应用的配置管理。本文将深入探讨这一主题，帮助开发者更好地理解和利用这一功能。 首先...