PS：创作不易，感谢阅读，希望对读者有所帮助，喜欢的话可以点赞、收藏、关注，作者会持续更新 Java 生态圈常见知识。黑色加粗为重点关注内容！

基本介绍

• 由容器动态的将某个依赖关系注入到组件之中，组件之间的依赖关系由容器在运行时决定
• 谁依赖于谁？
• 当然是应用程序依赖于 IoC 容器；
• 为什么需要依赖？
• 应用程序需要 IoC 容器来提供对象需要的外部资源；
• 谁注入谁？
• 很明显是 IoC 容器注入应用程序某个对象，应用程序依赖的对象；
• 注入了什么？
• 注入某个对象所需要的外部资源（包括对象、资源、常量数据）

Xml 配置方式

• 使用 xml 来声明 Bean 的定义，Spring 在启动时会加载并解析 xml，将 bean 装载到 IOC 容器中，具体有以下三种实现方式：
• set 注入：

public class User{
   privateString Username;
 
   publicString getUsername() {
       return username;
   }
   publicvoid setUsername(String username) {
      this.username= username;
   }
}

• 指定 id，class 值，id 值不做要求，class值为对象所在的完整路径。bean 标签再添加property 标签，要求 name 值与 User 类中对应的属性名称一致。value 值就是我们要给 User 类中的 username 属性赋的值

<bean id="userAction"class="com.lsz.spring.action.User" >
	<property name="username" value="admin"></property>
</bean>

• 构造方法注入

public class User{
    private String usercode;
    publicUser(String usercode) {
        this.usercode=usercode;
    }
}

<bean id="userAction" class="com.lsz.spring.action.User">                        
    <constructor-arg index="0" ref="值"></constructor-arg>
	// <constructor-arg type="Java.lang.String" value="值" ></constructor-arg>	
</bean>

• 接口注入：暂未整理

注解配置方式

• 使用 @CompontScan 注解来扫描声明了 @Service、@Controller、@Repository、@Component 的类
• @Service, 用于业务服务层
• @Controller, 用于控制层
• @Repository, 用于 DAO 层
• @Component, 通用组件，它是上面 3 个注解的父注解，没有明确的角色，对于普通的组件最好使用 @Component 注解

//Car.java
//将 Car 加上注解 @Component, 表明它是一个 Spring bean
@Component
public class Car {
    @Override
    public String toString() {
        return "Brand: Benz, price:1000";
    }
}

//Boss.java
//将 Boss 加上注解 @Component, 表明它是一个 Spring bean
//Boss 类的 field Car 是通过 @Autowired 注入的. 
@Component
public class Boss {
    @Autowired
    private Car car;

    @Override
    public String toString() {
        return "Boss has one car:("+car+")";
    }
} 

//SomeConfig.java
//这里创建 SomeConfig 类目的只有一个, 不用准备 Xml 配置文件. 
//在 main() 函数中将使用这个 config 类初始化容器, 并加上@ComponentScan, 告知 IoC 容器需要扫描指定 package 来获取 bean 的定义 (包括各种注解了@Component/@Service/@Controller/@Repository 的类). 
@Configuration
@ComponentScan("javaTestMaven.demo2")
public class SomeConfig {
}

//App.java
//入口函数,先初始化容器,然后通过容器获得 boss 对象
public class App {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.register(SomeConfig.class);
        context.refresh();
        Boss boss = context.getBean(Boss.class);
        System.out.println(boss);
        context.close();
    }
}

Java 配置方式

• 使用 @Configuration 注解来声明配置类，并使用 @Bean 注解标识那些需要 Spring 容器管理的对象
• Class 上不需要加上任何 IoC 相关的注解, 而是需要在 Config 类中使用 @Bean 来注解那些需要 Spring 容器管理的对象, @Bean 注解往往加在一个函数体上, 该函数需要返回一个对象.

//Car.java
//Car 类就是一个普通的 Class, 没有加@Component 注解
public class Car {
    @Override
    public String toString() {
        return "Brand: Benz, price:1000";
    }
}

//Boss.java
//Boss 类就是一个普通的 Class, 没有加@Component 注解
//Boss 类的 field Car 是通过 @Autowired 注入的. 
public class Boss {
    @Autowired
    private Car car;

    @Override
    public String toString() {
        return "Boss has one car:("+car+")";
    }
} 

//SomeConfig.java
//在上个示例中 SomeConfig 类目的只有一个, 不用准备 Xml 配置文件. 
//这个示例中 SomeConfig 类是一个重点, 不仅加了@Configuration, 而且使用了@Bean 注解定义了多个 Bean 对象
//因为所有的 Bean 都在 SomeConfig 类定义了, 所以 ComponentScan 注解可有可无.  
@Configuration
@ComponentScan("javaTestMaven.demo3")  //可有可无
public class SomeConfig {
    @Bean
    public Car car() {
        return new Car();
    }

    @Bean
    public Boss boss() {
        return new Boss();
    }
}

//App.java
//入口函数,先初始化容器,然后通过容器获得 boss 对象
public class App {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.register(SomeConfig.class);
        context.refresh();
        Boss boss = context.getBean(Boss.class);
        System.out.println(boss);
        context.close();
    }
}

注解配置方式和 Java 配置方式组合使用

• 注解配置方式和 Java 配置方式没有孰优孰劣, 理论上是可以相互替换的, 但可以总结一个最佳实践，通常，全局性的配置使用 Java 配置 (比如数据库相关配置, MVC 相关配置), 业务 Bean 配置使用注解配置, 尽量少用 Xml 配置方式
• 这本示例中, Boss bean 采用了 Java 配置方式, 而 Car bean 采用注解配置方式.

//Boss.java
//该 Java 没有加任何 IoC 注解
public class Boss {
    @Autowired
    private Car car;

    @Override
    public String toString() {
        return "Boss has one car:("+car+")";
    }
}

//Car.java
//该 Java 加上了基于注解的配置说明
@Component
public class Car {
    @Override
    public String toString() {
        return "Brand: Benz, price:1000";
    }
}

//SomeConfig.java
//该配置类中仅定义了 boss Bean, 没有直接定义 car Bean, 但实际上 Boss 对象中仍能被成功地注入 Car. 
//原因是我们组合使用了基于注解的配置方法, Config 类加上了@ComponentScan 后, IoC 容器能扫描到 Car 类 (因为其被注解为 Component). 
@Configuration
@ComponentScan("javaTestMaven.demo3")
public class SomeConfig {
    @Bean
    Boss boss() {
        return new Boss();
    }
}

//App.java
//入口函数,先初始化容器,然后通过容器获得 boss 对象
public class App {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.register(SomeConfig.class);
        context.refresh();
        Boss boss = context.getBean(Boss.class);
        System.out.println(boss);
        context.close();
    }
}

SpringBoot 程序的 @EnableAutoConfiguration

• 对于 SpringBoot 程序, 因为已经加了 @EnableAutoConfiguration, 所以可以省去注册 Config 类的过程.下面示例和上一个示例代码只有两处不同, 即 pom.xml 和 App.java 程序

//App.java
//基于 SpringBoot 的命令行程序
//无需注册 Config 类
@SpringBootApplication //same as @Configuration @EnableAutoConfiguration @ComponentScan
public class App implements CommandLineRunner {
    @Autowired
    private ApplicationContext context;

    public static void main(String[] args) throws Exception {
        SpringApplication app = new SpringApplication(App.class);
        app.setBannerMode(Banner.Mode.OFF);
        app.run(args);
    }

    // Put your logic here.
    @Override
    public void run(String... args) throws Exception {
        Boss boss = context.getBean(Boss.class);
        System.out.println(boss);
    }
}