个人博客地址：使用注解装配Bean

一、使用@Component（或@Named)注解

先来观察一下@Component这个注解的声明：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Indexed
public @interface Component {
    String value() default "";
}

从声明可以看出，@Target指明@Component可以标注的目标为ElementType.TYPE，TYPE包含类、接口（包括注解）和枚举类型，@Component注解有一个属性为value（注意String value() 不是方法，而是类型为String的value变量，默认值为""），用来指定Bean的名称。

装配一个Bean

下面是一段使用@Component注解装配Bean的示例代码：

package zb.spring.beans.pojo;

@Component()
public class Student {
    private String name;
	
    public String getName() {
        return name;
    }

    public Student setName(String name) {
        this.name = name;
        return this;
    }

    public void introduce(){
        System.out.println("我的名字叫" + name);
    }
}

没错，这样就装配了一个Bean,仅仅是在Student类上添加了一个@Component注解，装配的Bean的名称为类名首字母小写，当然也可以指定名称，如@Component("student")。做完了这些，我们还没有一个用来容纳这个Bean的Spring IoC容器（或应用上下文）。

创建应用上下文

现在观察下面的代码：

package zb.spring.beans;

public class BeansTest {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(Student.class);

        Student student = (Student) ctx.getBean("student");
        student.introduce();

    }
}

在这段代码中，首先声明并创建ApplicationContext（应用上下文）。注意子类使用的是AnnotationConfigApplicationContext，即基于注解配置的应用上下文，传入Student.class参数用来发现@Component注解（如果被注解标注的类不能被发现，那么它也仅仅是一个标注，没有任何逻辑上的作用）。
然后通过ApplicationContext的getBean(String)方法传入Bean的名称获取已经装配进容器的Student的一个实例，并且调用该实例的introduce()方法。执行结果为：

我们发现name属性为null，这是很正常的，因为我们除了声明Student为一个Bean之外，并没有给name属性设置任何值。

使用@Value注解给属性设值

将Student稍稍改动一下：

@Component
public class Student {
    @Value("Jason")
    private String name;

    public String getName() {
        return name;
    }

    public Student setName(String name) {
        this.name = name;
        return this;
    }

    public void introduce(){
        System.out.println("我的名字叫" + name);
    }
}

再次执行：

通过@Value注解，就给name属性设置了一个默认值。

使用@ComponentScan扫描多个Bean

通过这种方式能很方便地装配一个Bean，但实际中我们要为很多类装配Bean，那么就要考虑添加一个“中介”，使用这个“中介”初始化AnnotationConfigApplicationContext类，然后再由这个中介去发现更多的Bean。在zb.spring.beans.config包中添加StudentConfig类，代码如下：

package zb.spring.beans.config;

@ComponentScan(basePackages = {"zb.spring.beans.pojo"})
public class StudentConfig {
}

main方法中做如下更改：

ApplicationContext ctx = new AnnotationConfigApplicationContext(StudentConfig.class);

其中StudentConfig类就是一个“中介”，本身并没有任何逻辑，通过使用@ComponentScan注解，标注将会扫描整个zb.spring.beans.pojo包，该包下所有被@Component标注的类都会被发现并装配进容器中。可以看到，basePackages使用的是复数形式，并且包名由大括号包裹，说明basePackages是一个数组，可以传入多个需要扫描的包。如果没有指明basePackages的值，则默认扫描该“中介”所在的包。
在@ComponentScan中，还有一个属性basePackageClasses，从名字可以看出是一个类数组，这个类可以是一个@Component标注的类，也可以是另一个“中介”。

二、使用@Bean注解

同样先观察一下@Bean注解的声明：

@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Bean {
    @AliasFor("name")
    String[] value() default {};

    @AliasFor("value")
    String[] name() default {};

    /** @deprecated */
    @Deprecated
    Autowire autowire() default Autowire.NO;

    boolean autowireCandidate() default true;

    String initMethod() default "";

    String destroyMethod() default "(inferred)";
}

声明中可以看出，Target为方法和注解，在value属性和name属性上分别有@AliasFor(“name”)和@AliasFor(“value”)，这表示value和name是相同的。

装配一个Bean

在上面的例子中我们将Student的所有注解都去除，并将“中介”的代码改成如下所示：

package zb.spring.beans.config;

@Configuration
public class StudentConfig {
    @Bean
    public Student jason(){
        return new Student().setName("Jason");
    }

	@Bean
	public Student tom(){
		return new Student().setName("Tom");
	}
}

在“中介”类中，将@Bean注解到jason()或tom()方法上，则方法返回的对象会被作为Bean装配进容器中，Bean的名称默认为方法名，若要指定Bean名称，则可以通过设置Bean的value或name。
StudentConfig类上用的注解是@Configuration，而不是@Component，如果查看@Configuration的声明会发现，@Configuration也是由@Component声明的，如下所示：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Configuration {
    @AliasFor(
        annotation = Component.class
    )
    String value() default "";
}

这表示@Configuration本质上还是@Component，但要注意是是，被@Configuration标注的类下的Bean如果也被@Configuration标注，并不会做特殊处理，只会是一个普通的Bean，换句话说，该“中介”不会再接受其它的“中介”了。

使用@Configuration标注的类一般使用@Bean注解装配的方式装配Bean

以下是main方法：

package zb.spring.beans;

public class BeansTest {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(StudentConfig.class);

        Student jason = (Student) ctx.getBean("jason");
        Student tom = (Student) ctx.getBean("tom");

        jason.introduce();
        tom.introduce();
    }
}

执行结果为：

装配依赖于另一个Bean的Bean

我们知道在实际业务中类与类之间是相互依赖的，那么Spring IoC容器中Bean和Bean之间也需要相互依赖。
例如学生考试时需要依赖于笔：

package zb.spring.beans.pojo;

public class Pen {
    private String color;

    public Pen(String color){
        this.color = color;
    }
}

package zb.spring.beans.pojo;

public class Student {
    private String name;
    private Pen pen;

    public String getName() {
        return name;
    }

    public Student setName(String name) {
        this.name = name;
        return this;
    }

    public Pen getPen() {
        return pen;
    }

    public Student setPen(Pen pen) {
        this.pen = pen;
        return this;
    }

    public void introduce(){
        System.out.println("我的名字叫" + name);
    }

    public void write(){
        System.out.println(name + "使用" + pen.getColor() + "颜色的笔写了一行字");
    }
}

在装配Student这个Bean时需要将装配进Spring IoC容器的Pen装进Student中，观察下面的配置代码：

package zb.spring.beans.config;

@Configuration
public class StudentConfig {

    @Bean
    public Pen pen(){
        return new Pen("炭黑");
    }

    @Bean
    public Student jason(){
        Student jason = new Student();
        jason.setName("Jason");
        jason.setPen(pen());
        
        return jason;
    }
}

通过在setPen时调用装配Pen的方法可以从容器中获取Pen的Bean实例。

在main方法中调用Student类的write()方法：

public class BeansTest {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(StudentConfig.class);

        Student jason = (Student) ctx.getBean("jason");

        jason.introduce();
        jason.write();
    }
}

运行结果为：

当然，可能你会有疑问，这不就是调用'pen()方法返回一个对象吗？但是new Pen() == new Pen()可是不成立的，我需要是的Spring IoC中的Pen实例，而不是重新new一个。

其实在StudentConfig这个类中，pen()方法已经被@Bean注解标注了，那么在被Spring管理的其他Bean调用pen()方法时会被拦截并且注入Spring IoC中的Pen类的Bean（若在其他地方直接调用pen()方法则不会被管理）。下面修改main方法来验证一下：

ApplicationContext ctx = new AnnotationConfigApplicationContext(StudentConfig.class);

Student jason = (Student) ctx.getBean("jason");

Pen p1 = (Pen) ctx.getBean("pen");
Pen p2 = jason.getPen();
Pen p3 = new StudentConfig().pen();

System.out.println(p1);
System.out.println(p2);
System.out.println(p3);

运行结果：

可以看到前两个是同一个Bean实例，而直接调用pen()方法则会创建新的实例。

三、使用@Autowired注解自动装配

同样先观察@Autowired注解的声明：

@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {
    boolean required() default true;
}

Target有构造器、方法、参数、属性和注解，意味着@Autowired注解可以用在这四种类型上面。@Autowired有一个boolean类型的required属性，用于指定自动注入的Bean是否为必须，如果指定required为true，则容器中没有这个bean时会报异常。一般来说不会将required设为false，否则需要进行判空操作，以免出现空指针异常。

自动装配

在前面介绍的都是显式装配，其实在便利性方面，最强大的还是Spring的自动化配置，并且在大部分的情况下建议使用自动装配，因为这样可以减小配置的复杂度。（在Spring boot项目中，Controller依赖Service对象及Service依赖DAO层对象都是通过@Autowired自动装配完成的）

通过方法装配

将上一小节“装配依赖于另一个Bean的Bean”中的代码稍稍改一下：

@Component
public class Pen {
    @Value("炭黑")
    private String color;

    public String getColor() {
        return color;
    }
}

@Component("jason")
public class Student {
    @Value("jason")
    private String name;
    private Pen pen;

    public String getName() {
        return name;
    }

    public Student setName(String name) {
        this.name = name;
        return this;
    }

    public Pen getPen() {
        return pen;
    }

    @Autowired
    public Student setPen(Pen pen) {
        this.pen = pen;
        return this;
    }

    public void introduce(){
        System.out.println("我的名字叫" + name);
    }

    public void write(){
        System.out.println(name + "使用" + pen.getColor() + "颜色的笔写了一行字");
    }
}

在Student类中标注Student类为Bean，Bean的名称为"jason"，属性name为"Jason"，在setPen(Pen pen)方法上则标注了@Autowired注解。下面是配置类，去除了显式注入Bean的语句：

package zb.spring.beans.config;

@Configuration
@ComponentScan(basePackages = {"zb.spring.beans.pojo"})
public class StudentConfig {}

main方法改回原样：

ApplicationContext ctx = new AnnotationConfigApplicationContext(StudentConfig.class);

Student jason = (Student) ctx.getBean("jason");

jason.introduce();
jason.write();

运行结果为：

可以看到成功注入Pen。在方法上使用@Autowired注解，则此方法会被自动调用并且根据参数的类型自动从Spring IoC容器中找到匹配的Bean进行装配（有兴趣的可以在set方法中打印一条语句，即使setPen()方法没有显式调用过也会被Spring自动调用）。

通过参数装配

通过参数自动装配类似于通过方法装配，只是将@Autowired注解标注在参数上：

@Component("jason")
public class Student {

    @Value("Jason")
    private String name;

    private Pen pen;

    public Student(@Autowired Pen pen){
        this.pen = pen;
    }

    public String getName() {
        return name;
    }

    public Student setName(String name) {
        this.name = name;
        return this;
    }

    public Pen getPen() {
        return pen;
    }

    public Student setPen(Pen pen) {
        this.pen = pen;
        return this;
    }

    public void introduce(){
        System.out.println("我的名字叫" + name);
    }

    public void write(){
        System.out.println(name + "使用" + pen.getColor() + "颜色的笔写了一行字");
    }
}

在Student类中并没有空构造方法，而是带有@Autowired标注的Pen参数的构造方法，当Spring扫描到@Component注解时，Spring会自动发现这个构造方法并找到合适的Bean注入到参数上。运行结果同上。

通过属性装配

通过属性装配类似，将@Autowired标注到属性上即可：

@Autowired
private Pen pen;

运行结果同上。

@Primary和@Qualifier注解解决自动装配的歧义性

自动装配非常简单，但在某些情况下可能会出现歧义，如有一个Pen类和Pencil类都继承自Writable接口，而Student依赖于Writable而不是具体的Pen或Pencil，如下类图：

具体代码如下：

package zb.spring.beans.pojo;

public interface Writable {
    public void write(String sentence);
}

package zb.spring.beans.pojo;

@Component
public class Pen implements Writable{
    @Value("炭黑")
    private String color;

    public String getColor() {
        return color;
    }

    public void write(String sentence) {
        System.out.println("用" + color + "色的钢笔写下了\"" + sentence + "\"");
    }
}

package zb.spring.beans.pojo;

@Component
public class Pencil implements Writable {
    public void write(String sentence) {
        System.out.println("用铅笔写下了\"" + sentence + "\"");
    }
}

package zb.spring.beans.pojo;

@Component("jason")
public class Student{

    @Value("Jason")
    private String name;

    @Autowired
    private Writable writable;

    public String getName() {
        return name;
    }

    public Student setName(String name) {
        this.name = name;
        return this;
    }

    public Writable getWritable() {
        return writable;
    }

    public Student setWritable(Writable writable) {
        this.writable = writable;
        return this;
    }

    public void introduce(){
        System.out.println("我的名字叫" + name);
    }

    public void write(){
        System.out.print(name);
        writable.write("我是" + name);
    }
}

在Student类中，属性Writable被标注为@Autowired，那么应该是注入Pen呢还是Pencil呢？

下面看一下运行结果：

Caused by: org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type 'zb.spring.beans.pojo.Writable' available: expected single matching bean but found 2: pen,pencil
	at org.springframework.beans.factory.config.DependencyDescriptor.resolveNotUnique(DependencyDescriptor.java:217)
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(DefaultListableBeanFactory.java:1215)
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency(DefaultListableBeanFactory.java:1164)
	at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:593)
	... 14 more

运行报错。其中第一行有一句为：expected single matching bean but found 2: pen,pencil（期望匹配单个bean但是发现了2个：pen和pencil）。
在这种情况下我们可以通过@Primary或@Qualifier消除歧义：

使用@Primary

@Primary单词的意思是优先，顾名思义就是被标注的bean优先，比如在Pen这个类上加一个@Primary标注：

@Component
@Primary
public class Pen implements Writable{
    @Value("炭黑")
    private String color;

    public String getColor() {
        return color;
    }

    public void write(String sentence) {
        System.out.println("用" + color + "色的钢笔写下了\"" + sentence + "\"");
    }
}

运行结果为：

因为Pen被标注了@Primary优先，所以在寻找Writable的实现类的实例时不再有歧义（查看@Primary的声明发现并没有定义任何属性，也就是说一个接口的实现类中@Primary只能有一个，不会再定义精确的优先级，如果定义两个@Primary将会报错：more than one ‘primary’ bean found among candidates: [pen, pencil]）。

使用@Qualifier

@Primary是在接口的实现类中定义优先级，而@Qualifier则是在@Autowired自动注入时指定bean的名称，比@Primary更加的灵活。在Student类中进行如下修改：

@Autowired
@Qualifier("pencil")
private Writable writable;

此时运行结果为：

注意使用了@Qualifier之后@Primary注解将不会生效。