Spring学习总结(1)-注入方式

　　Spring实现控制反转（IOC）的思路是提供一些配置信息用来描述类之间的依赖关系，然后由容器去解析这些配置信息，继而维护好对象之间的依赖关系，前提是对象之间的依赖关系必须在类中定义好，比如A.class中有一个B.class的属性，那么我们可以理解为A依赖了B。既然我们在类中已经定义了他们之间的依赖关系那么为什么还需要在配置文件中去描述和定义呢？

 

Spring官方文档地址：https://docs.spring.io/spring/docs/5.2.1.BUILD-SNAPSHOT/spring-framework-reference/core.html#beans-factory-class

Spring实现IOC的思路大致可以拆分成3步骤：

　　（1）应用程序中提供类，提供依赖关系（属性或者构造方法）

　　（2）把需要交给容器管理的对象通过配置信息告诉容器（xml、annotation，javaconfig）

　　（3）把各个类之间的依赖关系通过配置信息告诉容器

 

Spring的注入编码风格有三种，并且三种可以混合使用：

　　（1）schemal-based    （实现方式：XML）

　　（2）annotation-based （实现方式：annotation注解）

　　（3）java-based           （实现方式：configuration注解）

　　

Spring官方推荐的注入方法有2种：

　　构造方法、setter方法，我们最常用的基于字段的注入方式，Spring官方是不推荐的。

　　在3.0版本时还有接口注入，因为不太人性化，后续的版本不推荐使用了。

 

1. schemal-based（XML）注入的两种方法：

1.1 构造方法注入

　　定义有参数的构造方法：

public class ThingThree {
    public ThingThree(ThingOne thingOne, ThingTwo thingTwo){
        // ...
    }
}

　　XML定义注入：

<beans>
    <bean id="thingOne" class="com.xxx.ThingOne"/>
    <bean id="thingTwo" class="com.xxx.ThingTwo"/>
    <bean id="thingThree" class="com.xxx.ThingThree">
        <constructor-arg ref="thingOne"/>
        <constructor-arg ref="thingTwo"/>
    </bean>
</beans>

1.2 setter方法注入

　　定义Setter方法：

public class BeanOne {
    private BeanTwo beanTwo;
    public void setBeanTwo(BeanTwo beanTwo){
        this.beanTwo = beanTwo;
    }
}

　　XML定义注入：

<beans>
    <bean id="beanOne" class="com.xxx.BeanOne"/>
    <bean id="thingTwo" class="com.xxx.ThingTwo">
        <property name="beanOne" ref="beanOne"/>
    <bean>
</beans>

　　另外XML还可以注入基本属性，比如：

<beans>
    <bean id="thingTwo" class="com.xxx.ThingTwo">
        <property name="str" value="Hello World"/>
    <bean>
</beans>

　　如果注入的属性在容器中已经存在，就可以用rel引用；如果不在容器中就用value引用值。bean还支持Map、List、Set的注入，但一般的不会用了。如果XML文件出现了p标签，代表了property，如果出现c标签，代表了constructor。

 

2. annotation-based （annotation注解）

　　bean使用的注解包括：@Component、@Repository、@Service、@Controller、@RestController，@Component是其他几个的父类

　　需要注入的类使用注解：@Autowired @Resource

　　使用annotation还不能独立使用，还需要开启注解，并在XML指定注解的扫描路径，因为Spring为了节省性能，默认是不开启注解的。

　　XML配置扫描路径：

<!-- 开启扫描功能，这个配置是Spring3.0版本才需要用 -->
<context:annotation-config></context:annotation-config>
<!-- 设置扫描路径、开启扫描，Spring4.0版本之后只用这一个就够了 -->
<context:component-scan base-package="com.xxx"/> 

 2.1 构造法方法注入

public class ThingThree {
    private ThingOne thingOne;
    private ThingTwo thingTwo;   
  
    @Autowire
    public ThingThree(ThingOne thingOne, ThingTwo thingTwo){
        this.thingOne = thingOne;
        this.thingTwo = thingTwo;
    }
}

2.2 setting方法注入

public class ThingThree {
    private ThingOne thingOne;
  
    @Autowire
    public setThingOne(ThingOne thingOne){
        this.thingOne = thingOne;
    }
}

2.3 字段注入

　　这是我们最常用的注入方式，但字段注入官方是不推荐的，我们在第五节详细分析。

public class ThingThree {
    @Autowire
    private ThingOne thingOne;

}

 

 

3. java-based（configuration注解）

　　在声明bean对象上使用注解：@Configuration

　　需要在bean类声明读取配置文件可以使用：@ImportResource("classpath:spring.xml")

　　bean上面设置组件扫描路径：@ComponentScan(basePackages = {"com.dxh.finance"})

 

4. 三种方式混合使用

　　下面这个其实是java-config、xml、annotation这3种方式混合使用的例子：

@Configuration
@ImportResource("classpath:spring.xml")
@ComponentScan(basePackages = {"com.dxh.finance"})
public class SpringConfig {

　　@Bean
　　public UserBean getBean(){
　　　　return new UserBean();　　
　　}

}

 

5. 基于字段的依赖注入缺点

对于有final修饰的变量不好使

　　Spring的IOC对待属性的注入使用的是set形式，但是final类型的变量在调用class的构造函数的这个过程当中就得初始化完成，这个是基于字段的依赖注入做不到的地方。只能使用基于构造函数的依赖注入的方式。

掩盖单一职责的设计思想

　　我们都知道在OOP的设计当中有一个单一职责思想，如果你采用的是基于构造函数的依赖注入的方式来使用Spring的IOC的时候，当你注入的太多的时候，这个构造方法的参数就会很庞大。

　　当你看到这个类的构造方法那么多参数的时候，你自然而然的会想一下：这个类是不是违反了单一职责思想?但是使用基于字段的依赖注入不会让你察觉，你会很沉浸在@Autowire当中。

与Spring的IOC机制紧密耦合

　　当你使用基于字段的依赖注入方式的时候，确实可以省略构造方法和setter这些个模板类型的方法，但是，你把控制权全给Spring的IOC了，别的类想重新设置下你的某个注入属性，没法处理(当然反射可以做到)。本身Spring的目的就是解藕和依赖反转，结果通过再次与类注入器（在本例中为Spring）耦合，失去了通过自动装配类字段而实现的对类的解耦，从而使类在Spring容器之外无效.

隐藏依赖性

　　当你使用Spring的IOC的时候，被注入的类应当使用一些public类型(构造方法，和setter类型方法)的方法来向外界表达：我需要什么依赖.但是基于字段的依赖注入的方式，基本都是private形式的，private把属性都给封印到class当中了。

无法对注入的属性进行安检

　　基于字段的依赖注入方式，你在程序启动的时候无法拿到这个类，只有在真正的业务使用的时候才会拿到，一般情况下，这个注入的都是非null的，万一要是null怎么办，在业务处理的时候错误才爆出来，时间有点晚了，如果在启动的时候就暴露出来，那么bug就可以很快得到修复(当然你可以加注解校验)。

　　如果你想在属性注入的时候，想根据这个注入的对象操作点东西，你无法办到．我碰到过的例子：一些配置信息啊，有些人总是会配错误，等到了自己测试业务阶段才知道配错了，例如线程初始个数不小心配置成了3000，机器真的是狂叫啊!这个时候就需要再某些Value注入的时候做一个检测机制。

结论

　　通过上面，我们可以看到，基于字段的依赖注入方式有很多缺点,我们应当避免使用基于字段的依赖注入.推荐的方法是使用基于构造函数和基于setter的依赖注入.对于必需的依赖项，建议使用基于构造函数的注入，以使它们成为不可变的，并防止它们为null。对于可选的依赖项，建议使用基于Setter的注入。