Spring @Autowired annotation is used for automatic dependency injection. Spring framework is built on dependency injection and we inject the class dependencies through spring bean configuration file.

Spring @Autowired批注用于自动依赖项注入。 Spring框架基于依赖注入 ，我们通过Spring bean配置文件注入类依赖。

Spring @Autowired批注 (Spring @Autowired Annotation)

Usually we provide bean configuration details in the spring bean configuration file and we also specify the beans that will be injected in other beans using ref attribute. But Spring framework provides autowiring features too where we don’t need to provide bean injection details explicitly.

通常，我们在spring bean配置文件中提供bean配置详细信息，并且我们还使用ref属性指定将注入其他bean中的bean。 但是，Spring框架也提供了自动装配功能，因此我们不需要显式提供bean注入细节。

There are different ways through which we can autowire a spring bean.

我们可以通过不同的方式来自动装配弹簧豆。

1. autowire byName – For this type of autowiring, setter method is used for dependency injection. Also the variable name should be same in the class where we will inject the dependency and in the spring bean configuration file.autowire byName –对于这种类型的自动装配，将setter方法用于依赖项注入。 同样，变量名在我们将要注入依赖项的类中以及在Spring bean配置文件中应该相同。
2. autowire byType – For this type of autowiring, class type is used. So there should be only one bean configured for this type in the spring bean configuration file.autowire byType –对于这种自动装配类型，使用类类型。 因此，在spring bean配置文件中应仅为此类型配置一个bean。
3. autowire by constructor – This is almost similar to autowire byType, the only difference is that constructor is used to inject the dependency.通过构造器进行自动装配–这几乎类似于通过类型自动装配，唯一的区别是构造函数用于注入依赖项。
4. autowire by autodetect – If you are on Spring 3.0 or older versions, this is one of the autowire options available. This option was used for autowire by constructor or byType, as determined by Spring container. Since we already have so many options, this option is deprecated. I will not cover this option in this tutorial.通过自动检测自动连线–如果您使用的是Spring 3.0或更早版本，则这是可用的自动连线选项之一。 该选项由构造器或byType用于自动装配，由Spring容器确定。 由于我们已经有很多选项，因此不建议使用此选项。 我不会在本教程中介绍此选项。
5. @Autowired annotation – We can use Spring @Autowired annotation for spring bean autowiring. @Autowired annotation can be applied on variables and methods for autowiring byType. We can also use @Autowired annotation on constructor for constructor based spring autowiring.

   For @Autowired annotation to work, we also need to enable annotation based configuration in spring bean configuration file. This can be done by context:annotation-config element or by defining a bean of type org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.

   @Autowired注释–我们可以使用Spring @Autowired注释进行Spring bean自动装配。 @Autowired批注可以应用于通过type自动装配的变量和方法。 我们还可以在构造函数上使用@Autowired注释，以进行基于构造函数的spring自动装配。

   为了使@Autowired注释起作用，我们还需要在spring bean配置文件中启用基于注释的配置。 这可以通过context：annotation-config元素或通过定义org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor类型的bean来完成。

6. @Qualifier annotation – This annotation is used to avoid conflicts in bean mapping and we need to provide the bean name that will be used for autowiring. This way we can avoid issues where multiple beans are defined for same type. This annotation usually works with the @Autowired annotation. For constructors with multiple arguments, we can use this annotation with the argument names in the method.@Qualifier批注–此批注用于避免bean映射中的冲突，我们需要提供将用于自动装配的bean名称。 这样，我们可以避免为同一类型定义多个bean的问题。 此注释通常与@Autowired注释一起使用。 对于具有多个参数的构造函数，我们可以在方法中将此注释与参数名称一起使用。

By default spring bean autowiring is turned off. Spring bean autowire default value is “default” that means no autowiring is to be performed. autowire value “no” also have the same behavior.

默认情况下，spring bean自动装配是关闭的。 Spring bean自动装配的默认值为“ default”，这意味着将不执行自动装配。 autowire值“ no”也具有相同的行为。

To showcase the use of Spring Bean autowiring, let’s create a simple Spring Maven project. Our final project will look like below image.

为了展示Spring Bean自动装配的用法，让我们创建一个简单的Spring Maven项目。 我们的最终项目将如下图所示。

Let’s look into each of the autowire options one by one. For that we will create a Model bean and a service class where we will inject the model bean.

让我们逐一研究每个自动接线选项。 为此，我们将创建一个Model Bean和一个服务类，在其中注入模型Bean。

Spring @Autowired注解– Maven依赖项 (Spring @Autowired Annotation – Maven Dependencies)

For spring autowiring, we don’t need to add any additional dependencies. Our pom.xml file has spring framework core dependencies and looks like below.

对于Spring自动装配，我们不需要添加任何其他依赖项。 我们的pom.xml文件具有spring框架核心依赖关系，如下所示。

<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>org.springframework.samples</groupId><artifactId>SpringBeanAutowiring</artifactId><version>0.0.1-SNAPSHOT</version><properties><!-- Generic properties --><java.version>1.6</java.version><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding><!-- Spring --><spring-framework.version>4.0.2.RELEASE</spring-framework.version><!-- Logging --><logback.version>1.0.13</logback.version><slf4j.version>1.7.5</slf4j.version></properties><dependencies><!-- Spring and Transactions --><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>${spring-framework.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-tx</artifactId><version>${spring-framework.version}</version></dependency><!-- Logging with SLF4J & LogBack --><dependency><groupId>org.slf4j</groupId><artifactId>slf4j-api</artifactId><version>${slf4j.version}</version><scope>compile</scope></dependency><dependency><groupId>ch.qos.logback</groupId><artifactId>logback-classic</artifactId><version>${logback.version}</version><scope>runtime</scope></dependency></dependencies>
</project>

Spring @Autowired注释–模型Bean (Spring @Autowired Annotation – Model Bean)

Let’s create a simple Java Bean, named Employee. This bean will have a single property with getter and setter methods. We will initialize this property value in the spring bean configuration file.

让我们创建一个名为Employee的简单Java Bean。 该bean将具有带有getter和setter方法的单个属性。 我们将在spring bean配置文件中初始化该属性值。

package com.journaldev.spring.autowiring.model;public class Employee {private String name;public String getName() {return name;}public void setName(String name) {this.name = name;}
}

Spring @Autowired注解–服务类 (Spring @Autowired Annotation – Service Class)

Let’s create our service class in which we will inject Employee bean through spring autowiring.

让我们创建我们的服务类，在其中将通过spring自动装配注入Employee bean。

package com.journaldev.spring.autowiring.service;import com.journaldev.spring.autowiring.model.Employee;public class EmployeeService {private Employee employee;// constructor is used for autowire by constructorpublic EmployeeService(Employee emp) {System.out.println("Autowiring by constructor used");this.employee = emp;}// default constructor to avoid BeanInstantiationException for autowire// byName or byTypepublic EmployeeService() {System.out.println("Default Constructor used");}// used for autowire byName and byTypepublic void setEmployee(Employee emp) {this.employee = emp;}public Employee getEmployee() {return this.employee;}
}

We will use the same service class for perform spring autowiring byName, byType and by constructor. The setter method will be used for spring autowiring byName and byType whereas constructor based injection will be used by constructor autowire attribute.

我们将使用相同的服务类来执行spring自动装配byName，byType和按构造函数。 setter方法将用于弹簧自动装配byName和byType，而基于构造函数的注入将由构造函数autowire属性使用。

When we use spring autowire byName or byType, default constructor is used. That’s why we have explicitly defined the default constructor for the EmployeeService bean.

当我们使用spring autowire byName或byType时，将使用默认构造函数。 这就是为什么我们为EmployeeService bean明确定义默认构造函数的原因。

Spring @Autowired注解–通过类型自动装配示例 (Spring @Autowired Annotation – autowiring byType Example)

Let’s create a separate class with Spring @Autowired annotation for autowiring byType.

让我们用Spring @Autowired注释创建一个单独的类，以自动装配byType。

package com.journaldev.spring.autowiring.service;import org.springframework.beans.factory.annotation.Autowired;import com.journaldev.spring.autowiring.model.Employee;public class EmployeeAutowiredByTypeService {//Autowired annotation on variable/setters is equivalent to autowire="byType"@Autowiredprivate Employee employee;@Autowiredpublic void setEmployee(Employee emp){this.employee=emp;}public Employee getEmployee(){return this.employee;}
}

Note that I have annotated both Employee variable and it’s setter method with Spring @Autowired annotation, however only one of these is sufficient for spring bean autowiring.

请注意，我已经用Spring @Autowired注释了Employee变量和它的setter方法，但是其中只有一个对于Spring bean自动装配是足够的。

Spring @Autowired注释和@Qualifier Bean通过构造器自动装配示例 (Spring @Autowired Annotation and @Qualifier Bean autowiring by constructor Example)

Let’s create another service class where we will use @Autowired annotation for constructor based injection. We will also see @Qualifier annotation usage.

让我们创建另一个服务类，在其中我们将使用@Autowired注释进行基于构造函数的注入。 我们还将看到@Qualifier注释用法。

package com.journaldev.spring.autowiring.service;import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;import com.journaldev.spring.autowiring.model.Employee;public class EmployeeAutowiredByConstructorService {private Employee employee;//Autowired annotation on Constructor is equivalent to autowire="constructor"@Autowired(required=false)public EmployeeAutowiredByConstructorService(@Qualifier("employee") Employee emp){this.employee=emp;}public Employee getEmployee() {return this.employee;}
}

When this bean will be initialized by Spring framework, bean with name as “employee” will be used for autowiring. Spring @Autowired annotation excepts one argument “required” that is a boolean with default value as TRUE. We can define it to be “false” so that spring framework don’t throw any exception if no suitable bean is found for autowiring.

当Spring框架初始化该bean时，将使用名称为“ employee”的bean进行自动装配。 Spring @Autowired注解除外，其中一个参数“ required”是布尔值，默认值为TRUE。 我们可以将其定义为“ false”，以便在找不到合适的bean进行自动装配时，spring框架不会引发任何异常。

Spring @Autowired注释– Bean配置文件 (Spring @Autowired Annotation – Bean Configuration File)

Spring bean configuration file is the main part of any spring application, let’s see how our spring bean configuration file looks and then we will look into each part of it.

Spring bean配置文件是任何spring应用程序的主要部分，让我们看看Spring bean配置文件的外观，然后我们将对其进行研究。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="https://www.springframework.org/schema/beans"xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"xmlns:context="https://www.springframework.org/schema/context"xsi:schemaLocation="https://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsdhttps://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context-4.0.xsd"default-autowire="byName" default-autowire-candidates="*" ><bean name="employee" class="com.journaldev.spring.autowiring.model.Employee"><property name="name" value="Pankaj"></property>
</bean><bean name="employee1" class="com.journaldev.spring.autowiring.model.Employee" autowire-candidate="false"><property name="name" value="Dummy Name"></property>
</bean><!-- autowiring byName, bean name should be same as the property name -->
<bean name="employeeServiceByName" class="com.journaldev.spring.autowiring.service.EmployeeService" autowire="byName" /><!-- autowiring byType, there should be only one bean definition for the mapping -->
<bean name="employeeServiceByType" class="com.journaldev.spring.autowiring.service.EmployeeService" autowire="byType" /><!-- autowiring by constructor -->
<bean name="employeeServiceConstructor" class="com.journaldev.spring.autowiring.service.EmployeeService" autowire="constructor" /><!-- Enable Annotation based configuration -->
<context:annotation-config /><!-- using @Autowiring annotation in below beans, byType and constructor -->
<bean name="employeeAutowiredByTypeService" class="com.journaldev.spring.autowiring.service.EmployeeAutowiredByTypeService" />
<bean name="employeeAutowiredByConstructorService" class="com.journaldev.spring.autowiring.service.EmployeeAutowiredByConstructorService" />
</beans>

Important points about spring bean configuration file are:

关于spring bean配置文件的要点是：

• beans element default-autowire is used to define the default autowiring method. Here I am defining the default autowiring method to be byName.beans元素default-autowire用于定义默认的自动装配方法。 在这里，我将默认的自动装配方法定义为byName。
• beans element default-autowire-candidates is used to provide the pattern for bean names that can be used for autowiring. For simplicity I am allowing all the bean definitions to be eligible for autowiring, however if we can define some pattern for autowiring. For example, if we want only DAO bean definitions for autowiring, we can specify it as default-autowire-candidates="*DAO".beans元素default-autowire-candidates用于为可用于自动default-autowire-candidates bean名称提供模式。 为简单起见，我允许所有bean定义都适合自动装配，但是如果我们可以定义一些自动装配模式。 例如，如果我们只希望DAO bean定义用于自动装配，则可以将其指定为default-autowire-candidates="*DAO" 。
• autowire-candidate="false" is used in a bean definition to make it ineligible for autowiring. It’s useful when we have multiple bean definitions for a single type and we want some of them not to be autowired. For example, in above spring bean configurations “employee1” bean will not be used for autowiring.在bean定义中使用autowire-candidate="false"使其不符合自动装配的条件。 当我们对一个类型有多个bean定义并且我们希望其中一些不自动装配时，这很有用。 例如，在上面的spring bean配置中，“ employee1” bean将不用于自动装配。
• autowire attribute byName, byType and constructor is self understood, nothing much to explain there.autowire属性byName，byType和构造函数是可以自我理解的，在此没有太多解释。
• context:annotation-config is used to enable annotation based configuration support. Notice that employeeAutowiredByTypeService and employeeAutowiredByConstructorService beans don’t have autowire attributes.context:annotation-config用于启用基于注释的配置支持。 请注意，employeeAutowiredByTypeService和employeeAutowiredByConstructorService Bean没有自动装配属性。

Spring @Autowired注解–测试程序 (Spring @Autowired Annotation – Test Program)

Now that our spring application is ready with all types of spring autowiring, let’s write a simple test program to see if it works as expected or not.

现在我们的spring应用程序已经可以使用所有类型的spring自动装配，现在让我们编写一个简单的测试程序来查看它是否按预期工作。

package com.journaldev.spring.autowiring.main;import org.springframework.context.support.ClassPathXmlApplicationContext;import com.journaldev.spring.autowiring.service.EmployeeAutowiredByConstructorService;
import com.journaldev.spring.autowiring.service.EmployeeAutowiredByTypeService;
import com.journaldev.spring.autowiring.service.EmployeeService;public class SpringMain {public static void main(String[] args) {ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("spring.xml");EmployeeService serviceByName = ctx.getBean("employeeServiceByName", EmployeeService.class);System.out.println("Autowiring byName. Employee Name="+serviceByName.getEmployee().getName());EmployeeService serviceByType = ctx.getBean("employeeServiceByType", EmployeeService.class);System.out.println("Autowiring byType. Employee Name="+serviceByType.getEmployee().getName());EmployeeService serviceByConstructor = ctx.getBean("employeeServiceConstructor", EmployeeService.class);System.out.println("Autowiring by Constructor. Employee Name="+serviceByConstructor.getEmployee().getName());//printing hashcode to confirm all the objects are of different typeSystem.out.println(serviceByName.hashCode()+"::"+serviceByType.hashCode()+"::"+serviceByConstructor.hashCode());//Testing @Autowired annotationsEmployeeAutowiredByTypeService autowiredByTypeService = ctx.getBean("employeeAutowiredByTypeService",EmployeeAutowiredByTypeService.class);System.out.println("@Autowired byType. Employee Name="+autowiredByTypeService.getEmployee().getName());EmployeeAutowiredByConstructorService autowiredByConstructorService = ctx.getBean("employeeAutowiredByConstructorService",EmployeeAutowiredByConstructorService.class);System.out.println("@Autowired by Constructor. Employee Name="+autowiredByConstructorService.getEmployee().getName());ctx.close();}
}

The program is simple, we are just creating the spring application context and using it to get different beans and printing the employee name.

该程序很简单，我们只是创建spring应用程序上下文，并使用它来获取不同的bean并打印员工姓名。

When we run above application, we get following output.

当我们在应用程序之上运行时，我们得到以下输出。

Mar 31, 2014 10:41:58 PM org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@3fa99295: startup date [Mon Mar 31 22:41:58 PDT 2014]; root of context hierarchy
Mar 31, 2014 10:41:58 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [spring.xml]
Default Constructor used
Default Constructor used
Autowiring by constructor used
Autowiring byName. Employee Name=Pankaj
Autowiring byType. Employee Name=Pankaj
Autowiring by Constructor. Employee Name=Pankaj
21594592::15571401::1863015320
@Autowired byType. Employee Name=Pankaj
@Autowired by Constructor. Employee Name=Pankaj
Mar 31, 2014 10:41:58 PM org.springframework.context.support.ClassPathXmlApplicationContext doClose
INFO: Closing org.springframework.context.support.ClassPathXmlApplicationContext@3fa99295: startup date [Mon Mar 31 22:41:58 PDT 2014]; root of context hierarchy

As you can see that for autowire byName and byType, default no-args constructor is used to initialize the bean. For autowire by constructor, parameter based constructor is used.

如您所见，对于autowire byName和byType，默认的no-args构造函数用于初始化bean。 对于通过构造函数进行自动装配，使用基于参数的构造函数。

From the hashcode of all the variables, we have confirmed that all the spring beans are different objects and not referring to the same object.

从所有变量的哈希码中，我们已经确认所有spring bean是不同的对象，而不是引用相同的对象。

Since we removed “employee1” from the list of eligible beans for autowiring, there was no confusion in the bean mapping. If we remove autowire-candidate="false" from the “employee1” definition, we will get below error message when executing the above main method.

由于我们从符合条件的bean列表中删除了“ employee1”以进行自动装配，因此在bean映射中没有混淆。 如果从“ employee1”定义中删除autowire-candidate="false" ，则在执行上述main方法时将得到以下错误消息。

Exception in thread "main" org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'employeeServiceByType' defined in class path resource [spring.xml]: Unsatisfied dependency expressed through bean property 'employee': : No qualifying bean of type [com.journaldev.spring.autowiring.model.Employee] is defined: expected single matching bean but found 2: employee,employee1; nested exception is org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type [com.journaldev.spring.autowiring.model.Employee] is defined: expected single matching bean but found 2: employee,employee1at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.autowireByType(AbstractAutowireCapableBeanFactory.java:1278)at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.populateBean(AbstractAutowireCapableBeanFactory.java:1170)at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:537)at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:475)at org.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactory.java:304)at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:228)at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:300)at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:195)at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:700)at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:760)at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:482)at org.springframework.context.support.ClassPathXmlApplicationContext.<init>(ClassPathXmlApplicationContext.java:139)at org.springframework.context.support.ClassPathXmlApplicationContext.<init>(ClassPathXmlApplicationContext.java:83)at com.journaldev.spring.autowiring.main.SpringMain.main(SpringMain.java:12)
Caused by: org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type [com.journaldev.spring.autowiring.model.Employee] is defined: expected single matching bean but found 2: employee,employee1at org.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(DefaultListableBeanFactory.java:967)at org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency(DefaultListableBeanFactory.java:855)at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.autowireByType(AbstractAutowireCapableBeanFactory.java:1263)... 13 more

That’s all for the Spring @Autowired Annotation and Spring autowiring feature, please download the example project from below link and analyse it to learn more.

这就是Spring @Autowired注释和Spring自动装配功能的全部内容，请从下面的链接下载示例项目并进行分析以了解更多信息。

翻译自: https://www.journaldev.com/2623/spring-autowired-annotation