依赖注入的概念
如果要在一个类中，使用另一个类，传统的方式是直接new：
class A{
//......
B b=new B();
//......
}
A类对象依赖于B类对象，如果没有B类对象，A类对象就不能正常工作，称为A依赖B。
上面的方式会增加A类与B类的耦合，不利于项目后期的升级（扩展）、维护。
在Spring中，B类的实例（被调用者），不再由A类（调用者）创建，而是由Spring容器创建，创建好以后，由Spring容器将B类实例注入A类实例中，称为依赖注入（Dependency Injection，DI）。
原本是由A类主动创建B类对象（A类控制B类的创建），现在是Spring容器创建B类对象，注入A类对象中，A类被动接受Spring容器创建的B类实例，B类对象创建的控制权发生了反转，所以又叫做控制反转（Inversion of Control，IoC）。
控制反转（IoC）是由依赖注入（DI）实现的，依赖注入又是由spring容器实现的，所以Spring容器又叫做Spring IoC容器。。
依赖注入是一种优秀的解耦方式，由Spring容器负责控制类（Bean）之间的关系，降低了类之间的耦合。
常用的方式有2种：
- 设值注入，也叫set方式注入
- 构造方法注入
设值注入
将依赖作为成员变量，通过主调类的setter方法注入依赖。
public class A {
private B b;
public void setB(B b) {
this.b = b;
}
//......
}
xml配置：
<bean name="b" class="com.chy.bean.B" />
<bean name="a" class="com.chy.bean.A">
<property name="b" ref="b"/>
</bean>
使用<property>注入依赖，name指定属性名（成员变量名），ref指定要注入的bean（value指定要注入的常量值）。
如果要注入多个依赖，使用多个<property />即可。
构造方法注入
将依赖作为成员变量，通过主调类的构造方法注入依赖。
public class A {
private B b;
public A(B b) {
this.b = b;
}
//......
}
xml配置：
<bean name="b" class="com.chy.bean.B" />
<bean name="a" class="com.chy.bean.A">
<constructor-arg name="b" ref="b" />
</bean>
一个<constructor-arg />注入一个参数，name指定构造方法中的形参名，ref指定要注入的bean（value指定要注入的常量值）。
形参可用 name="形参名" 指定，也可以使用 index="形参表下标" 来指定（第一个参数 => 下标0）。
如果有多个形参，使用多个<constructor-arg />即可，spring会调用对应的构造方法。
不管是设值注入，还是构造方法注入，都是将依赖作为成员变量，所以有时候也把注入依赖叫做注入属性。
依赖可分为3种类型：
- 注入int、float、String之类的基本数据类型，使用value。
比如根据学号查学生信息，需要注入一个int型的学号。
spring会自动将值转换为需要的类型，比如需要的String，value="chy"会以String的形式注入。value="1"，如果需要的是int，就转换为int注入，如果需要的是String，就转换为String注入。
- 注入其他Bean的实例，使用ref。
- 注入数组、集合、Properties等复杂类型
注入复杂类型的依赖
将复杂类型的数据数据作为成员变量：
private Object[] arr;
private List<Object> list;
private Set<Object> set;
private Map<String,Object> map;
private Properties properties;
设值注入需提供对应的setter方法，构造方法注入需提供对应的构造方法。
设值注入：
<bean name="a" class="com.chy.bean.A">
<!-- 注入数组-->
<property name="arr">
<array>
<!-- 基本数据类型使用value，bean的实例使用ref，可嵌套其他复杂类型-->
<value>chy</value>
<ref bean="b" />
</array>
</property> <!-- 注入List -->
<property name="list">
<list>
<value>chy</value>
<ref bean="b" />
</list>
</property> <!-- 注入Set -->
<property name="set">
<set>
<value>chy</value>
<ref bean="b" />
</set>
</property> <!-- 注入Map-->
<property name="map">
<map>
<!-- Map的key只能是String，基本数据类型用value，其他Bean的实例用value-ref -->
<entry key="id" value="1" />
<entry key="user" value-ref="b" />
</map>
</property> <!-- 注入Properties -->
<property name="properties">
<props>
<!-- 键、值都只能是String -->
<prop key="username">chy</prop>
<prop key="password">abcd</prop>
</props>
</property>
</bean>
<property name=""> name指定属性名（成员变量名）。
数组、List、Set的配置方式是差不多的。
构造方法注入：
<constructor-arg name="arr">
<array>
<value>chy</value>
<ref bean="b" />
</array>
</constructor-arg>
配置方式和设值注入差不多，只不过将 property 换为 constructor-arg ，name是指定形参名。
用的最多的是设值注入，因为很多时候都要修改成员变量的值，setter方法一般都要写，直接用setter方法设值注入，没必要再写带参的构造方法。
使用自动装配注入其它Bean的实例
原先注入其它bean的实例，需要使用<property />或<constructor />注入。
使用自动装配后，不需要使用<property />、<constructor />，spring会自动在容器中找到满足要求的其它bean，注入进来。
<bean name="a" class="com.chy.bean.A" autowire="byName" />
可选的值：
- no 默认值，不使用自动装配，如果要注入其它bean的实例，需要使用<property />或<constructor />。
- byName 根据name来自动装配
- byType 根据type来自动装配
- constructor 根据构造函数形参类型进行byType方式的自动装配
- default 使用全局默认的自动装配方式。
byName和byType都能在设值注入中使用，constructor只能在构造方法注入中使用。
byName
public class A {
private B b;
public void setB(B b) {
this.b = b;
}
}
<bean name="b" class="com.chy.bean.B" />
<bean name="a" class="com.chy.bean.A" autowire="byName" />
A依赖B，A中有对应的setter方法。
byName，name就是setter方法的方法名，去掉set，后面部分使用camel写法，比如setB() => b，
spring会自动到容器中找到name="b"的bean，注入。
name="b"的bean只能有一个，不然spring不知道要注入哪个。
byType
和byName差不多，也是要配合setter方法使用。不同的是：
byType，type是形参表的参数类型。比如setB(B b)，参数类型是B，Spring自动找到class=“B”的bean，注入。
class=“B”的bean只能有一个，不然spring不知道要注入哪个。
constructor
public class A {
private B b;
public A(B b) {
this.b = b;
}
}
顾名思议，需要和构造方法注入搭配使用。
找到带参的构造器，根据参数类型，按照byType的方式注入依赖。
default
使用全局默认的自动装配方式。
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"
default-autowire="byName"> <bean name="b" class="com.chy.bean.B" />
<bean name="a" class="com.chy.bean.A" autowire="default" />
</beans>
需要在根元素<beans>中设置全局默认的自动装配方式，所有default方式的自动装配都是使用 default-autowire 设置的方式进行装配。
自动装配的贪婪原则
自动装配会尽量多地注入依赖。
比如constructor ，有2个构造方法：（B b）、（B b, C c），如果容器中有B、C的实例，则优先调用（B b, C c），会尽量多地注入依赖。
自动装配的优点：一个属性就搞定，不必写大量的<property />或<constructor />。
缺点：自动装配只能注入其它bean的实例，使用时有限制条件。（可以和注入基本类型、复杂类型的方式一起使用。实际上，注入基本类型、bean的实例、复杂类型都可以搭配使用。）
使用SpEL注入依赖
SpEL，即Spring Expression Language，spring表达式语言。
使用SpEL可以注入基本类型，可以注入其它Bean，可以访问其它Bean的成员变量、调用其它Bean中的方法。
使用示例：
<bean name="score" class="com.chy.bean.Score">
<property name="chinese" value="#{90}" />
<property name="math" value="#{100}" />
<property name="english" value="#{95}" />
</bean>
<bean name="student" class="com.chy.bean.Student">
<property name="no" value="#{1}" />
<property name="name" value="#{'chy'}" />
<property name="score" value="#{score}" />
</bean>
SpEL放在#{ }中，数值型直接写，字符、字符串要加单引号，可以直接引用其它Bean。
SpEL使用的是设值注入，所以需要提供setter方法，只能用<property />注入值，不能使用构造方法注入。
不管值是什么类型，都只能用value，不能用ref。
可以直接访问其它Bean的成员变量，比如 #{score.math} ，实质是调用对应的getter方法，所以需要提供getter方法。
可以调用其它Bean的方法，比如 #{score.getMath()}，如果该方法返回void，作为null处理。