IOC理论推导

原来：

1. UserDao接口

public interface UserDao {
    void getUser();
}

2. UserDaoImpl实现类

public class UserDaoImpl implements UserDao{
    public void getUser(){
        System.out.println("默认获取用户");
    }
}

public class UserDaoSqlserverImpl implements UserDao{
    public void getUser(){
        System.out.println("sqlserver默认获取用户");
    }
}

3. UserService业务接口

public class UserDaoSqlserverImpl implements UserDao{
    public void getUser(){
        System.out.println("sqlserver默认获取用户");
    }
}

4. UserServiceImpl业务实现类

public class UserServiceImpl implements UserService{
    private UserDao userDao ;

    //利用set进行动态实现值注入
    public void setUserDao(UserDao userDao){
        this.userDao=userDao;
    }
    public void getUser(){
        userDao.getUser();
    }
}

5. 测试

public class MyTest {
    static void main(String[] args) {
        //用户实际调用的是业务层，Dao层他们不需要接触
        UserServiceImpl userService = new UserServiceImpl();
        ((UserServiceImpl)userService).setUserDao(new UserDaoSqlserverImpl());
        userService.getUser();
    }
}

在之前业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求修改原代码。如果程序代码量十分大，修改一次的成本代价身份昂贵。

使用一个set接口实现

    private UserDao userDao ;

    //利用set进行动态实现值注入
    public void setUserDao(UserDao userDao){
        this.userDao=userDao;
    }

• 之前，程序是主动创建对象。控制权在程序员
• 使用set注入后，程序不再具有主动性，而是变成了被动的接受对象

这种思想，从本质上解决了问题，程序员不用再去管理对象创建了。系统的耦合性大大降低，可以更加专注在业务的实现上！ 这是IOC原型

本质

控制反转IOC(Inversion of Control)，是一种设计思想，DI（依赖注入）是实现IOC的一种方法。也有人认为DI只是IOC的另一种说法，没有IOC的程序中，我们使用面向对象编程，对象的创建与依赖关系完全硬编码在程序中，对象的创建由程序自己控制,控制反转后将对象的创建转移给第三方,个人认为所谓控制反转就是获得依赖对象的方式反转了。
控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IOC容器，其实现方法是依赖注入(dependency Injection,DI)

Hello Spring

配置元数据：
resouces包下的<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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="daoImpl" class="com.god.dao.UserDaoImpl"/>
    <bean id="sqlserverImpl" class="com.god.dao.UserDaoSqlserverImpl"/>

    <bean id="userServiceImpl" class="com.god.service.UserServiceImpl">
    <!--
    ref:引用Spring容器中创建好的对象
    value：具体的值，基本数据类型
    -->
        <property name="userDao" ref="daoImpl"/>
    </bean>
</beans>

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

<!--使用Spring来创建对象，在Spring这些都称为Bean

    类型   变量名 = new   类型（）
    Hello hello = new Hello()

    id = 变量名
    class = new的对象的路径
    property相当于给对象中的属性设置一个值-->

    <bean id="Hello" class="com.god.pojo.Hello">
        <property name="str" value="Spring"/>
    </bean>
</beans>

实例化一个容器:
<MyTest.java>

import com.god.service.UserServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    static void main(String[] args) {
        //获取ApplicationContext；拿到Spring容器
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

        //容器在手。需要什么，就直接get什么
        UserServiceImpl userServiceImpl = (UserServiceImpl)context.getBean("userServiceImpl");
        userServiceImpl.getUser();
    }
}

要实现不同的操作，只需要在xml配置文件中进行修改，所谓的ioc，一句话搞定：对象由Spring来创建，管理，装配

IOC创建对象的方式

1. 使用无参构造创建对象，默认！
2. 假设我们要使用有参构造创建对象
   1.下标赋值

<!--第一种，下标赋值-->
    <bean id="user" class="com.god.pojo.User">
        <constructor-arg index="0" value="说java"/>
    </bean>

2.类型赋值

<!--第二种，通过类型创建。不建议使用-->
    <bean id="user" class="com.god.pojo.User">
        <constructor-arg type="java.lang.String" value="Dominus"/>
    </bean>

3.参数名赋值

<!--第三种：直接通过参数名 -->
    <bean id="user" class="com.god.pojo.User">
        <constructor-arg name="name" value="zlatan"/>
    </bean>

constructor-arg 是构造注入，依赖类的有参构造方法；property 是 setter 注入，依赖属性的 setter 方法。
总结：在配置文件加载的时候，容器中管理的对象就已经初始化了

Spring配置

别名

<!--别名，如果添加了别名，也可以使用别名获取到这个对象-->
    <alias name="user" alias="123"/>

Bean的配置

<!--
id:bean的唯一标识符，相当于对象名
class：bean对象所对应的全限定名：包名+类型
name：也是别名，而且name可以同时取多个别名-->

import

一般用于团队开发使用，可以将多个配置文件，导入合并为一个
项目中有多个人开发，不同人负责不同的类开发，不同的类需要注册在不同的bean中,我们可以利用import将所有人的beans.xml合并为一个总的(applicationContext.xml)。使用的时候，直接使用总的配置就可以了。

 <import resource="beans.xml"/>
 <import resource="beans1.xml"/>