spring依赖注入的理解与实践

大家好，最近小编有重温了一下spring的基础知识，这重温地过程中对spring知识的理解也更加深入。下面我将通过代码实践来阐述我对spring依赖注入的理解。

一.什么是依赖注入？

依赖注入（DI）是由IOC容器在运行期间动态地将某种依赖资源注入到对象之中，例如:让对象B通过依赖注入的方式赋值给对象A的成员变量。

二.依赖注入的实现方式：、

依赖注入的功能就是在使用spring框架创建对象的时候，动态的将它依赖的对象注入进bean当中。依赖注入的实现有两种最常见的实现方式，一种是构造方法注入，另一种是通过setter方法进行注入。

1.使用构造方法注入

原理：使用构造方法注入指的时Spring容器调用构造方法注入被依赖的实例（对象），构造方法可以是有参的或者是无参的。当spring读取配置信息后，会通过反射的方式调用实例的构造方法。如果是有参数构造方法，可以在构造方法中注入所需的参数值，最后创建类对象。

首先创建一个实体类：

public class User {
    private String id;
    private String name;
    private String password;
    //添加有参构造方法

    public User(String id, String name, String password) {
        this.id = id;
        this.name = name;
        this.password = password;
//用于判段spring是否使用此方法
        System.out.println("通过有参构造方法进行注入");
    }
    //添加toString()

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

再创建一个Spring配置文件进行有参构造注入属性

<?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">
<!--创建一个User类的Bean势力-->
    <bean id="user1" class="com.DI.User">
<!--进行有参构造赋值-->
        <constructor-arg name="id" value="1"/>
        <constructor-arg name="name" value="张三"/>
        <constructor-arg name="password" value="123"/>
    </bean>
    
</beans>

其中<constuctor-arg>元素是用于给User类的有参构造方法进行赋值操作。Spring通过        User类的构造方法获取<constuctor-arg>元素定义的值，最后这些值会被赋值给Spring创建User对象

创建一个测试类检验

package com.DI;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class userConstrtTest {
    public static void main(String[] args) {
        //加载配置文件，并且创建该实例
        ApplicationContext applicationContext = new
                ClassPathXmlApplicationContext("bean1.xml");
        //获取创建的对象实例
        User user = applicationContext.getBean("user1",User.class);
        //输出对象值
        System.out.println(user);
    }

}

查看控制台输出：

 可以看到成功创建user对象，并且是通过有参构造方法创建的。

2.通过setter方法进行注入操作

Setter方法注入是当今Spring最主流的注入方法，你可以再各种SSM项目中见到它的身影。此方法是最简单最直观的方法

首先依然是创建一个实体类;

package com.DI;

public class User2 {
    private String id;
    private String name;
    private String password;

    public void setId(String id) {
        this.id = id;
      //依旧进行打印跟踪
        System.out.println("set方法注入id属性");
    }

    public void setName(String name) {
        this.name = name;
        System.out.println("set方法注入name属性");
    }

    public void setPassword(String password) {
        this.password = password;
        System.out.println("set方法注入password属性");
    }

    @Override
    public String toString() {
        return "User2{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

然后创建一个spring配置文件创建相应的bean实例;

<?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">
<!--创建一个user bean实例-->
    <bean id="user2" class="com.DI.User2">
<!--进行setter方法赋值操作-->
        <property name="id" value="2"></property>
        <property name="name" value="李明"></property>
        <property name="password" value="456"></property>
    </bean>
</beans>

从代码中我们可以知道，当我们在使用setter方法进行诸如操作的时候，我们使用的是<property>标签，里面的name是用于指定字段名称，后面的value是用来设定具体值的。

编写测试类：

package com.DI;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestUser2 {
    public static void main(String[] args) {
        //加载配置文件
        ApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("bean2.xml");
        //获取bean创建的对象
        User2 user2 = applicationContext.getBean("user2", User2.class);
        System.out.println(user2);
    }
}

运行测试如下：

 成功创建对象实例!.并且通过我设定的路径跟踪信息可以知道这是通过setter方法进行注入操作的
 

接下来我们使用setter方法注入对象的实际应用操作：

1.编写dao层接口;

package com.DI.dao;
//创建一个业务逻辑接口
public interface UserDao {
    //定义一个方法用于模拟登录功能的实现
    public boolean login(String name,String password);
}

然后创建该接口的实现类：

package com.DI.dao.Impl;

import com.DI.dao.UserDao;

//创建一个业务逻辑接口
public class UserDaoImpl implements UserDao {


    public boolean login(String name, String password) {
        //如果名字是比尔和密码是123456就返回true
        if(name.equals("比尔")&&password.equals("12345")){
            return true;
        }
        return false;
    }
}

接下来编写服务层接口，userService

package com.DI.Service;
//服务层
public interface UserService {
    //创建服务层的登录方法
    public boolean login(String name,String password);
}

再创建userService的实现类

package com.DI.Service.Impl;
import com.DI.Service.UserService;
import com.DI.dao.UserDao;
//创建userservice的实现类
public class UserServiceImpl implements UserService {
    //创建一个UserDao类型的类变量
UserDao userDao;
//添加setter方法
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
//重写userService接口中的方法
    public boolean login(String name, String password) {
        return userDao.login(name,password);
    }
}

然后创建spring配置文件创建bean实例;

<?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">
<!--创建一个userDao的实例， <!--因为接口不能够实例化建对象，所以只能找他的子类建对象-->-->
    <bean id="userDaoImpl" class="com.DI.dao.Impl.UserDaoImpl"></bean>
<!--创建一个UserService实例并将userdao注入到userservice当中-->
    <bean id="userService" class="com.DI.Service.Impl.UserServiceImpl">
        <property name="userDao" ref="userDaoImpl"></property>
    </bean>
</beans>

由上述代码可知，我们先创建userDao接口实现类的bean，然后通过<property>标签中的ref 对userdao进行注入操作。

对于<property>标签进行解释：

name属性值：类里面属性名称

 ref属性：创建userDao对象bean标签id值

最后建立一个测试类进行测试操作

package com.DI.test;

import com.DI.Service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class userTYest {
    public static void main(String[] args) {
        ApplicationContext applicationContext=
                new ClassPathXmlApplicationContext("beanUser.xml");
        UserService userService =(UserService)applicationContext.getBean( "userService");
        boolean flag = userService.login("比尔","12345");
        if(flag){
            System.out.println("登录成功");
        }else{
            System.out.println("登录失败");
        }
    }

}

在这里我们的userService接口用器实现类创建的对象调用login方法进而调用userDao登录逻辑代码进行登录功能的实现，在这可以发现其中的妙处，不仅实现了简化代码还能够最大限度的解耦操作！

运行结果如下;

 登录成功！

接下来介绍注入不同类型的值进行操作

*3.注入属性-内部bean和级联赋值操作

-1.一对多关系：部门和员工，一个部门有多个员工，一个员工属于一个部门，部门是一，员工是多。

-2.在实体类表示一对多的关系，员工表示所属部门，使用对象类型属性进行表示。

（1）.内部bean

我们创建一个部门类：

package com.DI;
//部门类
public class Dept {
    private String dname;
//添加setter方法
    public void setDname(String dname) {
        this.dname = dname;
    }
//添加一个toString方法
 @Override
    public String toString() {
        return "Dept{" +
                "dname='" + dname + '\'' +
                '}';
    }
}

再创建一个员工类：

package com.DI;
//员工类
public class Employee {
    private String ename;
    private String gender;
    //员工属于某一个部门，使用对象形式进行表示
    private Dept dept;
    //为他们都添加相应的setter方法操作

    public void setEname(String ename) {
        this.ename = ename;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }

@Override
    public String toString() {
        return "Employee{" +
                "ename='" + ename + '\'' +
                ", gender='" + gender + '\'' +
                ", dept=" + dept +
                '}';
    }
}

建立一个spring配置文件

<?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-->
    <bean id="employee" class="com.DI.Employee">
<!--为其注入属性操作-->
        <property name="ename" value="汤姆"></property>
        <property name="gender" value="男"></property>
<!--设置对象类属性 以property嵌套bean的方式进行操作-->
        <property name="dept">
            <bean id="dept" class="com.DI.Dept">
                <property name="dname" value="安保部">
                </property>
            </bean>
        </property>
    </bean>
</beans>

在这个spring配置当中我们可以发现一个很有意思的嵌套：

在一个大bean当中嵌套着一个小bean，并对小bean进行setter注入值操作

然后进行测试：

package com.DI;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class employeeTest {
    public static void main(String[] args) {
        ApplicationContext applicationContext =new
                ClassPathXmlApplicationContext("bean4.xml");
        Employee employee = applicationContext.getBean("employee",Employee.class);
        System.out.println(employee);
    }
}

结果：

 成功输出该对象值！

(2).联级赋值操作

第一种写法：

重新建造一个spring配置文件：

<?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="employee" class="com.DI.Employee">
<!--设置两个普通属性-->
        <property name="ename" value="索亚"></property>
        <property name="gender" value="女"></property>
<!--级联赋值操作-->
        <property name="dept" ref="dept"></property>
    </bean>
<!--再创建一个bean-->
    <bean id="dept" class="com.DI.Dept">
        <property name="dname" value="财务部"></property>
    </bean>
</beans>

在测试类当中修改以下bean路径后进行试验：

 也成功输出;

第二种写法：

同样新建一个spring配置类;

<?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="employee" class="com.DI.Employee">
<!--设置两个普通属性-->
        <property name="ename" value="乔治"></property>
        <property name="gender" value="男"></property>
<!--级联赋值-->
        <property name="dept" ref="dept"></property>
        <property name="dept.dname" value="技术部"></property>
    </bean>
    <bean id="dept" class="com.DI.Dept">
        <property name="dname" value="财务部"></property>
    </bean>
</beans>

然后再进行测试;

可以发现乔治的部门被设定为技术部。

3.使用xml注入数组、集合属性操作 

 

*1.注入数组类型属性

*2.注入List集合类型属性

*3.注入Map集合

-1.创建类，定义数组、list、map、set类型属性，生成对应set方法

public class Student {
    //1.数组类型属性
    private String[] courses;

    //List集合类型属性
    private List<String> list;

    //3 map集合类型属性
    private Map<String,String> maps;

    //4. set集合类型属性
    private Set<String> sets;

    public void setSets(Set<String> sets) {
        this.sets = sets;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }

    public void setCourses(String[] courses) {
        this.courses = courses;
    }
}

创建spring配置文件

<?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">
<!--创建一个Student bean-->
    <bean id="student" class="com.DI.Student">
<!--数组类型属性注入-->
        <property name="courses">
            <array>
                <value>spring课程</value>
                <value>mybatis课程</value>
            </array>
        </property>
<!--list集合类型属性注入-->
        <property name="list">
            <list>
                <value>王五</value>
                <value>赵六</value>
            </list>
        </property>
<!--map类型属性注入-->
        <property name="maps">
            <map>
                <entry key="java" value="java"></entry>
                <entry key="python" value="python"></entry>
            </map>
        </property>
<!--set类型属性注入-->
        <property name="sets">
            <set>
                <value>Go</value>
                <value>c</value>
            </set>
        </property>
    </bean>
</beans>

创建一个测试类

可以看到成功输出。好了，这就是spring依赖注入，另外非常感你能够看完。