【Spring从入门到实战】第 3 讲：Spring中Bean的注入方式

本文已收录于专栏 🌲《Spring从入门到实战》🌲

专栏前言

   大家好，我是执梗。本专栏将从Spring入门开始讲起，详细讲解各类配置的使用以及原因，到使用SpringBoot进行开发实战，旨在记录学习生活的同时也希望能帮到大家，如果对您能有所帮助，还望能点赞关注该专栏，对于专栏内容有错还望您可以及时指点，非常感谢大家 🌹。

1.什么是Bean对象？

  我们上文以及讲过Spring的IOC容器，那么这个容器管理的对象，我们一般就成为Bean对象。我们以前平时生成一个对象，都是调用构造方法来new对象，对象都是由我们自己进行管理和生成，当我们将User对象托管给Spring管理后，此时的User就可以称之为是一个Bean对象，Spring可以帮我们去管理和生成对象，不需要我们自己去操作。
  当然并不是所有的对象Spring都得去帮我们管理，我们需要手动的去告诉它，这就是我们本文要讲的Bean的注入方式。

2.Bean的注入方式

1.XML注入

  这是Spring版本比较老的注入方式，当然现在大家都不怎么使用了，主要还是因为不方便，而且XML配置文件在SpringBoot中已经不使用了 。

1.1set注入

  在Spring的XML文件中，我们首先使用Bean标签注入我们需要注入的类，然后通过property标签的value属性完成赋值操作。它是基于注入类的set方法进行赋值的，如果property选择的属性没有set方法则会报错。
实体类代码：

@Data //自动注入所有get set方法，基于lombok
public class Student {
    String name;
    String id;
}
1
2
3
4
5

XML文件：

    <bean id="student" class="com.beans.Student">
        
        <property name="name" value="张三">property>
        <property name="id" value="1">property>
    bean>
1
2
3
4
5
6

主函数运行：

public class App {
    public static void main(String[] args) {
        //1.得到spring上下文对象
        ApplicationContext context=
                new ClassPathXmlApplicationContext("application.xml");
        //2.根据上下文对象提供的上下文对象
        Student student= (Student)context.getBean("student");
        System.out.println(student);
    }
}
1
2
3
4
5
6
7
8
9
10

正常打印

1.2构造方法注入

  这种注入方式也是在XML中进行，只不过我们使用的属性变成了constructor-arg，它基于的是构造方法的注入而不是我们的set方法了，需要我们的实体类提供对应的构造方法，否则也会报错。
实体类代码：

public class User {
    String name;
    int id;
    public User(String name, int id) {
        this.name = name;
        this.id = id;
    }
}
1
2
3
4
5
6
7
8

XML文件：

    <bean id="user" class="com.beans.User">
        <constructor-arg name="name" value="李四">constructor-arg>
        <constructor-arg name="id" value="2">constructor-arg>
    bean>
1
2
3
4
5

主函数运行：

public class App {
    public static void main(String[] args) {
        //1.得到spring上下文对象
        ApplicationContext context=
                new ClassPathXmlApplicationContext("application.xml")

        User user = context.getBean("user", User.class);
        System.out.println(user);
    }
}
1
2
3
4
5
6
7
8
9
10
11

正常打印

1.3 P标签注入

  这种注入方法其实本质上和set注入没有区别，因为它也是基于set方法进行实现的，如果缺失set方法的话同样会报错，感觉就是对set注入进行的一种简化，看上去更加简洁。
XML文件：

配置文件中请加入下面这行
xmlns:p="http://www.springframework.org/schema/p"

    <bean id="car" class="com.beans.Student" p:name="王五" p:id="3"/>
1
2
3
4

正常打印：

1.4静态工厂注入

  这种注入方式比较少见，它是调用静态工厂的静态方法来创建Bean，当我们需要对象时，只需要传入参数调用静态方法即可，不需要关心创建对象的细节问题。当然被注入的实体类同样需要提供set方法，它也是基于set注入实现。我们还需要再配置文件中配置静态工厂的路径和调用方法名以及参数。需要注意的是静态工厂中厂本身不需要创建，可以直接通过静态方法调用。

实体类：

@Data
public class User {
    String name;
    int id;
    public User() {

    }
}
1
2
3
4
5
6
7
8

XML配置文件:

	
    
    <bean id="createuser" class="com.beans.UserStaticFactory" factory-method="UserCreate">
        
        <constructor-arg value="赵六">constructor-arg>
        <constructor-arg value="6">constructor-arg>
    bean>
1
2
3
4
5
6
7

主函数运行:

public class App {
    public static void main(String[] args) {
        //1.得到spring上下文对象
        ApplicationContext context=
                new ClassPathXmlApplicationContext("application.xml");

        User user = context.getBean("createuser", User.class);
        System.out.println(user);
    }
}
1
2
3
4
5
6
7
8
9
10

正常打印:

1.5实例工厂注入

  这个和上面的静态工厂有点类似，不同的区别在于实例工厂注入，我们首先需要把这个工厂注入进Spring。然后在注入实体类的时候我们需要指明我们使用的是哪一个注入的工厂以及调用的是工厂内的哪个方法，主要的区别就在于静态工厂是不需要注入工厂的，而我们实例工厂注入由于需要实例化工厂对象，所以需要讲工厂也注入进来。注意的是改方法注入同样依赖与set方法。

XML配置

	此处是注入工厂
<bean id="factorname" class="com.beans.UserStaticFactory">bean>
    
    <bean id="student2" class="com.beans.UserStaticFactory"
          factory-bean="factorname"  factory-method="UserCreate">
        <constructor-arg value="李易峰">constructor-arg>
        <constructor-arg value="6">constructor-arg>
    bean>
1
2
3
4
5
6
7
8
9
10
11

主函数运行：

public class App {
    public static void main(String[] args) {
        //1.得到spring上下文对象
        ApplicationContext context=
                new ClassPathXmlApplicationContext("application.xml");

        User user = context.getBean("student2", User.class);
        System.out.println(user);
    }
}
1
2
3
4
5
6
7
8
9
10

正常打印：

3.XML注入的缺点

  当然现在主流开发都是使用的SpringBoot框架，我们一般不采用XML配置文件的方法去注入对象，主要它有以下缺点：

• XML文件配置麻烦，占用资源，维护代码的同时还得维护配置文件
• 当注入的实体类过多时，配置文件代码量很大，维护麻烦
• 程序编译难以对配置文件进行验证，会产生运行时异常且难以发现

4.注解注入

  这是目前最主流的注入方式，我们只需要在我们需要注入的实体类上加上相应的注解就可以Spring我们需要去注入它。当然它也没有那么只能，你在任何地方写它都能识别到，我们首先需要配置包的扫描路径，这样它才会将该包下的所有添加注解的类注入。

在 application.xml添加如下配置：

base-package="需要扫描的包路径"
<context:component-scan base-package="com.beans">context:component-scan>
1
2

1.@Controller

  @Controller注解主要用于控制层，表明我们将该类注入进Spring管理，注意该类路径需要在扫描的包下。

实体类代码:

@Controller
public class UserController {
    public void sayHi(String name){
        System.out.println("Hi"+name);
    }
}
1
2
3
4
5
6

主函数运行代码：
  这里需要注意的是我们类名叫UserController这种大驼峰命名，但是在通过context取对象时却是userController，这是Spring约定熟成的规矩。

public class App {
    public static void main(String[] args) {
        //1.得到spring上下文对象
        ApplicationContext context=
                new ClassPathXmlApplicationContext("application.xml");
                
        UserController userController = context.getBean("userController", UserController.class);
        userController.sayHi("张飞");
    }
}
1
2
3
4
5
6
7
8
9
10

正常运行：

2.@Service

  同样具有注入功能，只不过我们一般写在Service层。

@Service
public class UserService {
    public void sayHi(String name){
        System.out.println("Hi"+name);
    }
}
1
2
3
4
5
6

3.@Repository

  同样具有注入功能，我们一般用在数据访问层，也就是常说的DAO层。

@Repository
public class UserRepository{
    public void sayHi(String name){
        System.out.println("Hi"+name);
    }
}
1
2
3
4
5
6

4.@Component

  同样具有注入功能，它指的是我们注入的是一个组件，那么什么是组件呢？我也说不清楚哈哈哈，反正不是使用上面的三种的情况下我们就使用该注解注入。

@Component
public class UserComponent {
    public void sayHi(String name) {
         System.out.println("Hi"+name);
    }
}
1
2
3
4
5
6

5.@Configuration

  同样具有注入功能，它表示我们注入的类是一个配置类。

@Configuration
public class UserConfiguration {
    public void sayHi(String name) {
         System.out.println("Hi"+name);
    }
}
1
2
3
4
5
6