1. 构造器注入（前边已讲）
2. Set方式注入【重点】
2.1 依赖注入含义

依赖：bean对象的创建依赖于容器
注入：bean对象的所有属性，由容器来注入

2.2 环境搭建

复杂类型

创建引用类型Address

public class Address {

    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Address{" +
                "address='" + address + '\'' +
                '}';
    }
}


真实测试对象

创建类Student

package com.kuang.pojo;

import lombok.Data;
import java.util.*;

@Data
public class Student {
    private String name;
    private Address address;/*引用类型*/
    private String[] books;/*数组类型*/
    private List<String> hobbys;/*集合类型*/
    private Map<String, String> card;
    private Set<String> games;
    private String wife;/*空指针类型，有没有妻子*/
    private Properties info;/*配置类*/

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", address=" + address.toString() +
                ", books=" + Arrays.toString(books) +
                ", hobbys=" + hobbys +
                ", card=" + card +
                ", games=" + games +
                ", wife='" + wife + '\'' +
                ", info=" + info +
                '}';
    }
}



beans.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
       
    <bean id="student" class="com.kuang.pojo.Student">
        <!--String类型的注入： 使用value-->
        <property name="name" value="星时"></property>
    </bean>
    
</beans>


测试类

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("beans.xml");
        Student student = (Student) context.getBean("student");
        System.out.println(student.getName());
    }
}

2.3 完善注入

注入

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="address" class="com.kuang.pojo.Address">
        <property name="address" value="东胜神洲花果山水帘洞"></property>
    </bean>

    <bean id="student" class="com.kuang.pojo.Student">
        <!--String注入: 使用value-->
        <property name="name" value="星时"></property>
        <!--bean注入: 使用ref-->
        <property name="address" ref="address"></property>
        <!--数组注入-->
        <property name="books">
            <array>
                <value>杀死一只知更鸟</value>
                <value>醒来觉得甚是爱你</value>
                <value>明朝那些事儿</value>
            </array>
        </property>
        <!--list注入-->
        <property name="hobbies">
            <list>
                <value>象棋</value>
                <value>羽毛球</value>
                <value>跑步</value>
            </list>
        </property>
        <!--map注入-->
        <property name="card">
            <map>
                <entry key="身份证" value="2394872394382472935482"></entry>
                <entry key="银行卡" value="4357293854729384752398"></entry>
                <entry key="饭卡" value="294723945735732854548557"></entry>
            </map>
        </property>
        <!--Set注入-->
        <property name="games">
            <set>
                <value>王者荣耀</value>
                <value>和平精英</value>
                <value>红色警戒</value>
            </set>
        </property>
        <!--null注入-->
        <property name="wife">
            <null/>
        </property>
        <!--properties(配置)注入-->
        <property name="info">
            <props>
                <prop key="姓名">星时</prop>
                <prop key="年龄">232</prop>
                <prop key="智商">250</prop>
                <prop key="email">23424729@qq.com</prop>
            </props>
        </property>
    </bean>
</beans>


测试

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("beans.xml");
        Student student = (Student) context.getBean("student");
        System.out.println(student.toString());

        /*运行结果：
        * Student{
        * name='星时',
        * address=Address{address='东胜神洲花果山水帘洞'},
        * books=[杀死一只知更鸟, 醒来觉得甚是爱你, 明朝那些事儿],
        * hobbys=[象棋, 羽毛球, 跑步],
        * card={
        *       身份证=2394872394382472935482,
        *       银行卡=4357293854729384752398,
        *       饭卡=294723945735732854548557
        *       },
        * games=[王者荣耀, 和平精英, 红色警戒],
        * wife='null',
        * info={
        *       智商=250,
        *       email=23424729@qq.com,
        *       姓名=星时,
        *       年龄=232
        *      }
        * }
        * */
    }
}

3. 拓展方式注入
3.1 p命名空间注入——主要针对无参构造方法

User类

@Data
public class User {
    private String name;
    private int age;

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}


userBean.xml

<?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:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--
        xmlns:p="http://www.springframework.org/schema/p"：导入p命名空间
        xmlns:c="http://www.springframework.org/schema/c"：导入c命名空间
    -->
    <!--p命名空间注入，可以直接注入属性的值: property-->
    <bean id="user" class="com.kuang.pojo.User" p:name="阿飞" p:age="14"/>
</beans>


测试方法

@Test
public void test(){
    ApplicationContext context=new ClassPathXmlApplicationContext("userBean.xml");
    User user = context.getBean("user", User.class);/*第二个参数表示的是user的类型*/
    System.out.println(user.toString());
}

<!--
    运行结果：
            User{name='阿飞', age=14}
-->

3.2 c命名空间注入——主要针对有参构造方法

User类（相比上边多了两个构造方法）

@Data
public class User {
    private String name;
    private int age;

    public User() {
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}


userBean.xml

<?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:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--
        xmlns:p="http://www.springframework.org/schema/p"：导入p命名空间
        xmlns:c="http://www.springframework.org/schema/c"：导入c命名空间
    -->
    <!--p命名空间注入，可以直接注入属性的值: property-->
    <bean id="user" class="com.kuang.pojo.User" p:name="阿飞" p:age="14"/>

    <!--c命名空间注入，通过构造器注入: constructs-args-->
    <bean id="user2" class="com.kuang.pojo.User" c:name="星时" c:age="123"/>
</beans>


测试方法

@Test
public void test(){
    ApplicationContext context=new ClassPathXmlApplicationContext("userBean.xml");
    User user = context.getBean("user2", User.class);/*第二个参数表示的是user的类型*/
    System.out.println(user.toString());
}

<!--
    运行结果：
            User{name='星时', age=123}
-->

注意：使用p命名空间和c命名空间需要导入约束

控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI）。下面我们就为大家介绍一下php依赖注入的三种方式。

一、构造器注入

　　将被依赖对象通过构造函数的参数注入给依赖对象，并且在初始化对象的时候注入。

优点：

　　对象初始化完成后便可获得可使用的对象。

缺点：

　　●当需要注入的对象很多时，构造器参数列表将会很长；

　　●不够灵活。若有多种注入方式，每种方式只需注入指定几个依赖，那么就需要提供多个重载的构造函数，麻烦

二、setter方法注入

　　IoC Service Provider通过调用成员变量提供的setter函数将被依赖对象注入给依赖类。

优点：

　　灵活。可以选择性地注入需要的对象。

缺点：

　　依赖对象初始化完成后由于尚未注入被依赖对象，因此还不能使用。

三、接口注入

　　依赖类必须要实现指定的接口，然后实现该接口中的一个函数，该函数就是用于依赖注入。该函数的参数就是要注入的对象。

优点

　　接口注入中，接口的名字、函数的名字都不重要，只要保证函数的参数是要注入的对象类型即可。

缺点

　　侵入行太强，不建议使用。

PS：什么是侵入行？

　　如果类A要使用别人提供的一个功能，若为了使用这功能，需要在自己的类中增加额外的代码，这就是侵入性。

以上就是php依赖注入的三种方式的详细内容，更多请关注php中文网其它相关文章！

spring依赖注入的三种方式以及优缺点

一.依赖注入的三种方式

1.通过构造器注入。（spring4.3之后，推荐使用）

2.通过setter注入。（spring4.3之前，推荐使用）

3通过filed注入。

二.三种方式的代码示例：

Constructor注入

    private AlarmContactService alarmContactService;

	private final AlarmService alarmService;

	private final SysUserService sysUserService;

    @Autowired
	public AlarmContactController(AlarmContactService alarmContactService, AlarmService alarmService,
			SysUserService sysUserService) {
		this.alarmContactService = alarmContactService;
		this.alarmService = alarmService;
		this.sysUserService = sysUserService;
	}

Setter注入

private AlarmContactService alarmContactService;

	private AlarmService alarmService;

	private SysUserService sysUserService;

	@Autowired
	public void setAlarmContactService(AlarmContactService alarmContactService) {
		this.alarmContactService = alarmContactService;
	}

	@Autowired
	public void setAlarmService(AlarmService alarmService) {
		this.alarmService = alarmService;
	}

	@Autowired
	public void setSysUserService(SysUserService sysUserService) {
		this.sysUserService = sysUserService;
	}

Field注入

    @Autowired
	private AlarmContactService alarmContactService;

	@Autowired
	private AlarmService alarmService;

	@Autowired
	private SysUserService sysUserService;

三.3种方式的各优点和缺点

三种方式的优点分析

1.基于构造器注入，会固定依赖注入的顺序，不允许我们创建的bean对象之间存在循环依赖关系，这样Spring能解决循环依赖的问题。

2.基于setter注入，只有对象是需要被注入的时候，才会注入依赖，而不是在初始化的时候就注入。

3.在成员变量上写上注解来注入，这种方式，精短，可读性高，不需要多余的代码，也方便维护。

三种方式的缺点分析

1.使用构造器注入的缺点是，当我们构造器需要注入的对象比较多时，会显得我们的构造器，冗余，不美观，可读性差，也不易维护。

2.当我们选择setter方法来注入的时候，我们不能将对象设为final的；

3.当我们在field变量上来实现注入的时候

    a.这样不符合JavaBean的规范，而且很有可能引起空指针；

    b.同时也不能将对象标为final的；

　 c.类与DI容器高度耦合，我们不能在外部使用它；

    d.类不通过反射不能被实例化（例如单元测试中），你需要用DI容器去实例化它，这更像集成测试；

 

来自Spring官方文档的建议：  

在Spring 3.x 中，Spring团队建议我们使用setter来注入：

而在Spring 4.x 中，Spring团队不再建议我们使用setter来注入，改为了constructor：

Spring团队通常建议使用构造器来注入，因为它允许一个应用程序组件实现为不可变对象，并确保所需的依赖项不是空。此外构造器注入组件总是返回一个完全初始化状态的client客户端(调用)。附注，大量的构造函数参数是一个糟糕的代码习惯，看起来也很坏，这意味着类可能有太多的责任，应该被重构，以更好地解决适当的关注点分离。

 

三.解释下什么是循环依赖：

1. 循环依赖是什么？

Bean A 依赖 B，Bean B 依赖 A这种情况下出现循环依赖。

Bean A → Bean B → Bean A     或者 Bean A → Bean B → BeanC → Bean A

2. 循环依赖会产生什么结果？

当Spring正在加载所有Bean时，Spring尝试以能正常创建Bean的顺序去创建Bean。

例如，有如下依赖:


Bean A → Bean B → Bean C


Spring先创建beanC，接着创建bean B（将C注入B中)，最后创建bean A(将B注入A中)。

假如，有如下循环依赖：

Bean A → Bean B → Bean C → BeanD → Bean A  



 

但当存在循环依赖时，Spring将无法决定先创建哪个bean。这种情况下，Spring将产生异常BeanCurrentlyInCreationException。

 

一条Spring 4.3 的新特征：

在Spring 4.3 以后，如果我们的类中只有单个构造函数，那么Spring就会实现一个隐式的自动注入：

就是我去掉了构造器上的@Autowired注解，经测试后发现，程序能正常运行。alarmContactService，alarmService，sysUserService的依赖也被成功注入了。

    private AlarmContactService alarmContactService;

	private final AlarmService alarmService;

	private final SysUserService sysUserService;

	public AlarmContactController(AlarmContactService alarmContactService, AlarmService alarmService,
			SysUserService sysUserService) {
		this.alarmContactService = alarmContactService;
		this.alarmService = alarmService;
		this.sysUserService = sysUserService;
	}

使用构造注入允许加入final，这也表示以后不能再被更改了。

 

 

控制反转(Inversion of Control，缩写为IoC)，是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入(Dependency Injection，简称DI)。下面我们就为大家介绍一下php依赖注入的三种方式。
一、构造器注入
将被依赖对象通过构造函数的参数注入给依赖对象，并且在初始化对象的时候注入。
优点：
对象初始化完成后便可获得可使用的对象。
缺点：
●当需要注入的对象很多时，构造器参数列表将会很长；
●不够灵活。若有多种注入方式，每种方式只需注入指定几个依赖，那么就需要提供多个重载的构造函数，麻烦
二、setter方法注入
IoC Service Provider通过调用成员变量提供的setter函数将被依赖对象注入给依赖类。
优点：
灵活。可以选择性地注入需要的对象。
缺点：
依赖对象初始化完成后由于尚未注入被依赖对象，因此还不能使用。
三、接口注入
依赖类必须要实现指定的接口，然后实现该接口中的一个函数，该函数就是用于依赖注入。该函数的参数就是要注入的对象。
优点
接口注入中，接口的名字、函数的名字都不重要，只要保证函数的参数是要注入的对象类型即可。
缺点
侵入行太强，不建议使用。
PS：什么是侵入行？
如果类A要使用别人提供的一个功能，若为了使用这功能，需要在自己的类中增加额外的代码，这就是侵入性。