006，Spring注解方式装配Bean

V哥官网：http://www.vgxit.com

本博客对应视频教程：http://www.vgxit.com/course/23

---

Spring注解方式装配Bean

---

1，概述

通过之前的学习，我们己经知道如何使用XML的方式去装配Bean但是更多的时候我们已经不再推荐使用XML的方式去装配Bean(注意，XML装配Bean的知识你还是要会)，更多时候会考虑使用注解的方式去装配Bean。使用注解的方式可以减少XML的配置，并且注解功能更为强大，它既能实现XML的功能，也提供了自动装配的功能，采用了自动装配后，程序员所需要做的决断就少了，更加有利于对程序的开发，这就是“约定由于配置” 的开发原则。

在Spring中，提供了两种方式来发现Bean:

• 组件扫描：通过定义资源的方式，让Spring Ioc容器扫描对应的包，从而把Bean装配进来。
• 自动装配：通过定义注解，让一些依赖关系可以通过注解完成。

因为使用注解的方式来开发Spring应用已经是主流了，所以，我们后续的课程主要还是基于注解来讲解的。

---

2，使用@Component装配Bean:

1，我们定义一个类，到时候使用这个类来装配bean:

package com.vgxit.learn.spring.ktdm.vgannioc.beans;

import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
@Data
public class Dog {
    @Value("1")
    private Integer id;

    @Value("丑丑")
    private String name;

    @Value("贵宾犬")
    private String breed;
}

2，定义类之类：

package com.vgxit.learn.spring.ktdm.vgannioc;

import org.springframework.context.annotation.ComponentScan;

@ComponentScan
public class VgAnnIocConfig {
}

3，测试代码：

package com.vgxit.learn.spring.ktdm.vgannioc.test;

import com.vgxit.learn.spring.ktdm.vgannioc.VgAnnIocConfig;
import com.vgxit.learn.spring.ktdm.vgannioc.beans.Dog;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class VganniocTest01 {
    public static void main(String[] args) {
        //获取Spring的上下文
        ApplicationContext ctx = new AnnotationConfigApplicationContext(VgAnnIocConfig.class);
        Dog dog = (Dog) ctx.getBean("dog");
        System.out.println(dog);
    }
}

代码分析：

1，@Component注解代表Spring会把这个注解修饰的类扫描成bean。这个注解的value属性就相当于我们在XML中配置的bean的id。我们在开发的时候也可以不用指定value属性，在不指定的时候，spring会自动给我们生成一个id，这个id就是我们的类名首字母小写。

2，注解@Value代表的是值的注入，这里我们只是简单的注入了一些值。这个地方id是int类型。这个时候我们不用操心，Spring会自己知道帮我们转换的

3，我们定义了一个类VgAnnIocConfig。这个类就相当于我们之前用过得xml的配置文件，我们就可以理解成它就是Spring的一个配置类。这个类里面使用了一个注解@ComponentScan，这个注解代表的就是扫描当前包和子包。

4，使用了注解的方式注入bean之后，我们开发的时候的上下文用AnnotationConfigApplicationContext

---

3，自定义扫描包

按照之前讲的方式，我们定义的扫描配置只能扫描配置类对应的包和子包。但是在真实的开发中，我们更多的情况是需要自定义要扫描的包的路径，这个时候如何解决呢？

@ComponentScan有一个属性叫做basePackages，这个属性是一个数组，这个数组里面存放的就是我们要扫描的包的路劲。只要你配置了这个属性了，Spring会自动的扫描你配置的包和下面的子包。4

---

4，自定义扫描类

就是我们还可以通过指定对应的类的方式来进行扫描，如果我们指定了对应的类，那么Spring会扫描对应的类所在包下面的所有类。

@ComponentScan(basePackageClasses = Cat.class)
public class VgAnnIocConfig {
}

---

5，按类型获取Bean

按照之前我们的学习，我们获取对应的bean是通过id来获取的。其实Spring还给我们提供了通过类型获取Bean的方式。

public class VganniocTest01 {
    public static void main(String[] args) {
        //获取Spring的上下文
        ApplicationContext ctx = new AnnotationConfigApplicationContext(VgAnnIocConfig.class);
        //在ioc容器中找到对应的类型的bean，然后返回
        Dog dog = ctx.getBean(Dog.class);
        Cat cat = ctx.getBean(Cat.class);
        System.out.println(dog);
        System.out.println(cat);
    }
}

---

6，自动装配

我们上面给大家介绍的Dog，Cat这些类的属性，要不是int，要不就是String。反正都是一些简单数据类型，但是如果有一个类是复杂数据类型的怎么办？

1，首先，我们给Cat（猫）定义一个主人类：

package com.vgxit.learn.spring.ktdm.vgannioc.beans;

import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
@Data
public class Master {
    @Value("1")
    private Integer id;

    @Value("V哥")
    private String name;
}

2，然后改造我们的Cat类：

package com.vgxit.learn.spring.ktdm.vgannioc.beans;

import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
@Data
public class Cat {
    @Value("1")
    private Integer id;

    @Value("汤圆")
    private String name;

    @Value("美短")
    private String breed;

    @Autowired//这个注解回去Spring的ioc容器中寻找对应类型的bean，然后引用过来
    private Master master;
}

这里我们使用了AutoWried注解。这个注解的作用是，Spring把所有的Bean都生成好了之后，如果发现了有这个注解，Spring就会按照这个属性的类型去Spring容器里面找到对应的已经创建好的Bean，然后注入到这个属性中。

上面我们讲了自动装配，但是是有一些问题的。比如我们的Master没有注入到IOC容器中的时候，上面程序报错。但是有的时候，我们就希望如果容器中有对应类型的Bean就引用过来。如果没有对应类型的Bean那么就不要应用。这个时候，我们可以使用AutoWired的required属性。

@Autowired(required = false)
private Master master;

这里我们说一下，我们除了配置属性之外，还可以配置属性方法。比如我们可以在属性对应的set方法上来配置这个注解完成。但是没有必要，因为对于PO，我们一般都是使用lombok来开发。然后对于Service，Controller我们根本就没有为属性提供get和set方法的必要。

---

7，自动装配的歧义

我们上面讲解了Autowried注解，使用它是非常简单的，并且可以完成自动装配的功能。它是按照类型来匹配。这个时候会产生一些问题。

比如我们定义一个接口叫做Cat：

package com.vgxit.learn.spring.ktdm.vgannioc.beans;
public interface Cat {
    void say();
}

他分别有两个实现类，一个是MeiduanCat，一个是LihuaCat:

package com.vgxit.learn.spring.ktdm.vgannioc.beans;

import org.springframework.stereotype.Component;

@Component
public class MeiduanCat implements Cat {
    @Override
    public void say() {
        System.out.println("喵喵");
    }
}

package com.vgxit.learn.spring.ktdm.vgannioc.beans;

import org.springframework.stereotype.Component;

@Component
public class LihuaCat implements Cat {
    @Override
    public void say() {
        System.out.println("哈哈");
    }
}

然后，我们把Cat类型引用到另外一个bean中。

package com.vgxit.learn.spring.ktdm.vgannioc.beans;

import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
@Data
public class Master {
    @Autowired
    private Cat cat;

    public void catSay() {
        cat.say();
    }
}

这个时候我们运行，直接报错，这个是因为Cat是借口，对应有两个实现类，一个是MeiduanCat一个是LihuaCat。我们使用Autowried注解来注入一个Cat的时候，Spring发现有两个不同类型的对象都是可以注入的。这个时候，Spring就不知道该注入哪一个了。这个时候程序直接报错。

---

7，注解Primary

注解Primary代表受邀的，当Spring IOC通过一个接口或者抽象类注入对象的时候，如果存在了多个实现类。spring就不知道该注入哪一个好了。这个我们可以使用Primary注解。这个注解的作用就是告诉Spring容器，优先使用我来注入。

@Component
@Primary
public class LihuaCat implements Cat {
    @Override
    public void say() {
        System.out.println("哈哈");
    }
}

---

8，注解Qualifier

上面我们可以是用Primary注解来设置一个有限注入的对象。但是有的时候还是不能满足我们的需求，因为使用了这个注解之后，我们只要使用的AutoWired注解来注入对象的时候，都会注入加入了Primary注解的对象。而其他对象就无法注入进来了。这个时候，Spring给我们提供了一个按照名称来注入的方式。这个名称就是Bean的id。

1，在注入的Component的时候，我们指定Bean的id

package com.vgxit.learn.spring.ktdm.vgannioc.beans;

import org.springframework.stereotype.Component;

@Component("lihuaCat")
public class LihuaCat implements Cat {
    @Override
    public void say() {
        System.out.println("哈哈");
    }
}

package com.vgxit.learn.spring.ktdm.vgannioc.beans;

import org.springframework.stereotype.Component;

@Component("meiduanCat")
public class MeiduanCat implements Cat {
    @Override
    public void say() {
        System.out.println("喵喵");
    }
}

2，在引用的时候，我们通过Qualifier注解来引用对应的Bean

package com.vgxit.learn.spring.ktdm.vgannioc.beans;

import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

@Component
@Data
public class Master {
    @Autowired
    @Qualifier("meiduanCat")
    private Cat cat;

    public void catSay() {
        cat.say();
    }
}

---

9，注解+构造方法注入

package com.vgxit.learn.spring.ktdm.vgannioc.beans;

import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

@Component
@Data
public class Master {
    private Cat cat;

    public Master(@Autowired @Qualifier("lihuaCat") Cat cat) {
        this.cat = cat;
    }

    public void catSay() {
        cat.say();
    }
}

---

10，使用Bean注解：

上面我们都是通过Component来装配Bean。但是Component注解只能用在类上面，不能用在方法上面。但是，如果我们遇到我们要注入一个第三方包提供的类，我们应该怎么办呢？

比如，我们使用Druid来创建一个数据库连接池，但是我们希望这个连接池要让spring来管理。但是Druid阿里巴巴给我们提供的是第三方的开源包，我们不可能去修改源代码让其带上Component注解。这个时候我们又希望要注入，怎么办？

1，导入druid和mysql驱动:

<dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.2.5</version>
            </dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.21</version>
    <scope>runtime</scope>
</dependency>

2,我们修改BeanConfig类，让其成为一个配置类。加上Configuration注解。

package com.vgxit.learn.spring.ktdm.vgannioc.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@ComponentScan(basePackages = "com.vgxit.learn.spring.ktdm.vgannioc.beans")//定义扫描包的路劲
@Configuration//表明这个类是一个配置类
public class VgAnnIocConfig {
}

3，定义druid数据库连接的属性，druid.properties：

driverClassName=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis.ktdm?serverTimezone=Asia/Shanghai
username=root
password=Abc@123456
# 初始化连接数量
initialSize=5
# 最大连接数
maxActive=10
# 最大等待时间
maxWait=3000

4，提供获取数据库连接池的方法：

package com.vgxit.learn.spring.ktdm.vgannioc.config;

import com.alibaba.druid.pool.DruidDataSourceFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import javax.sql.DataSource;
import java.io.InputStream;
import java.util.Properties;

@ComponentScan(basePackages = "com.vgxit.learn.spring.ktdm.vgannioc.beans")//定义扫描包的路劲
@Configuration//表明这个类是一个配置类
public class VgAnnIocConfig {
    /**
     * 定义一个获取数据源的方法
     * @return
     */
    @Bean(name = "dataSource")//我们把方法返回的数据源作为一个Bean注入到Spring容器中
    public DataSource getDataSource() throws Exception {
        Properties properties = new Properties();
        InputStream druidInputStram = VgAnnIocConfig.class.getClassLoader().getResourceAsStream("druid.properties");
        properties.load(druidInputStram);
        DataSource ds = DruidDataSourceFactory.createDataSource(properties);
        return ds;
    }
}

5，编写数据库连接池的使用方法：

package com.vgxit.learn.spring.ktdm.vgannioc.test;

import com.vgxit.learn.spring.ktdm.vgannioc.config.VgAnnIocConfig;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class VganniocTest002 {
    public static void main(String[] args) throws SQLException {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(VgAnnIocConfig.class);
        DataSource ds = ctx.getBean(DataSource.class);
        //新的语法来给大家写try resources
        Connection conn = ds.getConnection();
        PreparedStatement ps = conn.prepareStatement("select * from user");
        ResultSet rs = ps.executeQuery();
        try (conn; ps; rs){
            while (rs.next()) {
                System.out.println(rs.getInt("id") + "-------->" + rs.getString("name"));
            }
        }
    }
}

---

10，单例注入和多例注入

我们上面的所有的注入方式，在Spring中其实使用单例的方式的。也就是我们创建好了对应的Bean之后，放到Spring容器中，我们要用得时候，Spring自己去IOC容器里面拿出来给我们用就好了。但是，我们还可以进过配置让Spring用多例的方式给我们创建。多例注入的意思，就是我们要使用的时候，spring会给我们立马创建一个（new一个）出来，然后给我们使用。

比如，我们来看看原来的使用方式：

package com.vgxit.learn.spring.ktdm.vgannioc.beans;

import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

@Component
@Data
public class Master {
    @Autowired @Qualifier("lihuaCat")
    private Cat cat;

    public Master() {
        System.out.println("创建了Master对象");
    }

    public void catSay() {
        cat.say();
    }
}

然后，我们通过spring容器两次获取了对应的Master对象：

public static void main(String[] args) {
        //获取Spring的上下文
        ApplicationContext ctx = new AnnotationConfigApplicationContext(VgAnnIocConfig.class);
        //在ioc容器中找到对应的类型的bean，然后返回
        Master master1 = ctx.getBean(Master.class);
        master1.catSay();
        Master master2 = ctx.getBean(Master.class);
        master2.catSay();
    }

然后我们发现Master对应的构造方法被调用了两次。

但是如果我们使用多例的注入方式，那么对应的代码如下：

package com.vgxit.learn.spring.ktdm.vgannioc.beans;

import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
@Data
@Scope("prototype")//这种方式就是多例的注入方式
public class Master {
    @Autowired @Qualifier("lihuaCat")
    private Cat cat;

    public Master() {
        System.out.println("创建了Master对象");
    }

    public void catSay() {
        cat.say();
    }
}

这个时候我们重新运行测试代码，可以发现Family的构造方法被调用了两次，这个可以证明，Spring每次都给我们创建了一个新对象。在默认情况下@Scope默认的方式就是单例的。如果我们要配置多列可以用@Scope("prototype")，当然我们要手动实现单例可以使用@Scope("singleton")

如果我们使用xml的方式来配置单例和多列，可以使用bean标签的scope属性。这里老师就不给大家演示了，大家自己下来手动实验一下。