SpringIoC实现原理 附代码

IoC称作控制反转。控制反转是一种思想，实现它的方式叫依赖注入(DI)，其实是一回事。
它的思想是实现对象间的解耦，一般我们在实现业务的时候必然会使得两个对象相互联系共同完成业务。比如要再对象A中实例化对象B，这样的代码就需要再对象A中初始化，可能在A的构造函数中就要对成员对象B初始化，耦合度较高。
现在spring中把所有对象的控制权从各个对象剥夺出来，照理对象A要用到对象B，对象A对B有控制权，现在改成对象A对向spring申请对象B。对象A不用管B是如何生成的，只有拿来用就可以。举个例子，吃饭的时候我们要用筷子，我们可能需要走到厨房打开盒子自己去拿，甚至我们要去大街上买筷子，现在变成我一伸手，就有别人从一个容器中给了我们筷子。
实现的代码，我感觉就是工厂模式，对读各种类信息的xml文件，spring帮我们生成好了。
在spring boot中用的是注解@Autowired方式。
springIoC实现代码如下：有两种方式
一、属性set方法方式

public interface UserDao {
    void save();
}

public class UserDaoImp implements UserDao {
    @Override
    public void save() {
        System.out.println("持久层，保存用户");
    }
}

package com.Model;

public class Car1 {

    private String name;
    private double money;

    public Car1(String name, double money) {
        this.name = name;
        this.money = money;
    }

    public void display(){
        System.out.println("汽车出街");
    }

    public String toString() {
        return "Car1 [name=" + name + ", money=" + money + "]";
    }

}

public interface UserService {
    void save();
}

public class UserServiceImp implements UserService {
    private UserDao userDao;
    private String msg;

    public void setUserDaoImp(UserDao userDao) {
        this.userDao = userDao;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    @Override
    public void save() {
        System.out.println("业务层");
        userDao.save();
    }
}

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p"
       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">
    <!--IOC入门
        把Service类配置,管理实体类,使用bean标签
        id:给对象在容易中提供一个唯一标识,用于获取对象
        class:要管理类的全路径
        scope:管理对象的作用范围
        prototype:多例的
        request:WEB项目中,Spring创建一个Bean的对象,将对象存入到request域中
        session:WEB项目中,Spring创建一个Bean的对象,将对象存入到session域中
        globalsession:WEB项目中,应用在Portle环境,如果没有Portlet环境,那么globalsession相当于session
        initial-method:指定类中的初始化方法名称
        destroy-method:指定类中销毁方法名称
        -->
    <!--
        <bean id="us" class="cn.itcast.demo1.UserServiceImpl" scope="prototype" init-method="init"/>
        <bean id="ud" class="cn.itcast.demo1.UserDaoImpl2"/>-->

    <!--Bean对象的三种实例化方式
        1.使用无参构造函数(默认)
        <bean id="us" class="cn.itcast.demo1.UserServiceImpl" scope="prototype" init-method="init"/>
        2.Spring管理静态工厂,使用静态工厂的方法创建对象
        public class StaticFactory {
            public static UserDao createDao(){
                return new UserDaoImpl();
            }
        }
        <bean scope="singleton" class="demo3.StaticFactory" id="staticFactory" factory-method="createDao"/>
        3.Spring管理实例工厂,使用实力工厂的方法创建对象
        public class NoStaticFactory {
            public UserDao createDao() {
                return new UserDaoImpl();
            }
        }
        <bean id="noStaticFactory" class="demo3.NoStaticFactory"/>
        <bean id="ud" factory-bean="noStaticFactory" factory-method="createDao"/>-->

    <!--依赖注入
        1.属性set方法方式-->
    <bean id="cd" class="com.Dao.UserDaoImp"/>
    <bean id="cs" class="com.Service.UserServiceImp">
        <property name="userDaoImp" ref="cd"/>
        <property name="msg" value="美美"/>
    </bean>
</beans>

@Test
    public void fun(){
        System.out.println("test测试");
        ApplicationContext applicationCtontext = new ClassPathXmlApplicationContext("ApplicationContext1.xml");
        UserService cs = (UserService) applicationCtontext.getBean("cs");
        cs.save();
    }

二、属性构造方式

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p"
       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">
    <!--IOC入门
        把Service类配置,管理实体类,使用bean标签
        id:给对象在容易中提供一个唯一标识,用于获取对象
        class:要管理类的全路径
        scope:管理对象的作用范围
        prototype:多例的
        request:WEB项目中,Spring创建一个Bean的对象,将对象存入到request域中
        session:WEB项目中,Spring创建一个Bean的对象,将对象存入到session域中
        globalsession:WEB项目中,应用在Portle环境,如果没有Portlet环境,那么globalsession相当于session
        initial-method:指定类中的初始化方法名称
        destroy-method:指定类中销毁方法名称
        -->
    <!--
        <bean id="us" class="cn.itcast.demo1.UserServiceImpl" scope="prototype" init-method="init"/>
        <bean id="ud" class="cn.itcast.demo1.UserDaoImpl2"/>-->

    <!--Bean对象的三种实例化方式
        1.使用无参构造函数(默认)
        <bean id="us" class="cn.itcast.demo1.UserServiceImpl" scope="prototype" init-method="init"/>
        2.Spring管理静态工厂,使用静态工厂的方法创建对象
        public class StaticFactory {
            public static UserDao createDao(){
                return new UserDaoImpl();
            }
        }
        <bean scope="singleton" class="demo3.StaticFactory" id="staticFactory" factory-method="createDao"/>
        3.Spring管理实例工厂,使用实力工厂的方法创建对象
        public class NoStaticFactory {
            public UserDao createDao() {
                return new UserDaoImpl();
            }
        }
        <bean id="noStaticFactory" class="demo3.NoStaticFactory"/>
        <bean id="ud" factory-bean="noStaticFactory" factory-method="createDao"/>-->

    <!--依赖注入
        1.属性set方法方式-->
    <!--2.属性的构造方法的方式-->
    <bean id="car1" class="com.Model.Car1">
        <constructor-arg name="name" value="BMW"/>
        <constructor-arg name="money" value="1000000"/>
    </bean>
</beans>

public class Main {
    @Test
    public void fun(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("ApplicationContext2.xml");
        Car1 car = (Car1)applicationContext.getBean("car1");
        System.out.println(car);
        car.display();
    }
}