关于对Spring--Ioc的理解

Spring : 就是一个轻量级的控制反转（IOC） 和面向切面编程的（AOP）的框架

Spring 容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从Ioc容器中取出需要的对象

Ioc 本质

控制反转 IoC（inversion of control）是一种设计思想，DI（依赖注入）是实现IOC的一种方法。没有IoC的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。

采用XML方式配置Bean的时候，Bean 的定义信息是和实现分离的，而采用注解方式可以把两者合为一体，Bean 的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。

控制反转是一种通过描述（XML或注解）并通过第三方生产获取特定对象的方式，在Spring中实现控制反转的是IOC容器，其实现方法是依赖注入（dependency injection DI）

控制反转：

控制 : 谁来控制对象的创建，传统应用程序的对象是由程序本身控制创建的，使用Spring后，对象是由Spring 来创建的

反转 : 程序本身不创建对象，而变成被动的接收对象

依赖注入 : 利用set方法来进行注入的

IOC是一种编程思想，由主动的编程变成被动的接收

要实现不同的操作，只需要在XML配置中进行修改，

所谓的IOC 一句话： 对象由Spring 来创建，管理，装配！

案例1：

dao层：

public class Hello {
    private String str;

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

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

xml配置：

<!--使用Spring 来创建对象， 在Spring 这些都成为Bean
    类型 变量名 = new  类型();
    Hello hello = new Hello();

    id = 变量名
    class = new 的对象
    property 相当于给对象中的属性设置一个值
-->
<bean id="hello" class="com.kuang.pojo.Hello">
    <property name="str" value="你好Spring"/>
</bean>

测试类：

public static void main(String[] args) {
    //使用xml配置 必有的new对象 固定的 ClassPathXmlApplicationContext
    //获取Spring的上下文对象
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

    //对象现在都在Spring中管理，我们要使用，直接去里面取出来就可以！
    Hello bean = (Hello) context.getBean("hello");
    System.out.println(bean.toString());
}

案例2：

dao 层 接口：

public interface UserDao {
    void getUser();
}

dao层实现类：

public class UserDaoMysqlImpl implements UserDao {
    public void getUser() {
        System.out.println("Mysql-获取用户数据");
    }
}

业务层接口：

public interface UserService {
    void getUser();
}

业务层实现类：

public class UserServiceImpl implements UserService {

    //业务层调用dao层
    /**
     * private UserDao userDao = new UserDaoMysqlImpl();
     * 之前程序是主动创建对象，控制全在程序员手里，
     * 使用set 注入后，程序不在具有主动性，而是变成被动的接收对象
     *
     * 我们 不用在管理对象的创建了，系统的耦合性降低，更加专注在业务的实现上，ioc 原型
     */
    
    private UserDao userDao ; 

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

beans.xml配置：

	//创建了一个UserDaoMysqlImpl对象，变量名为mysqlImpl
<bean id="mysqlImpl" class="com.kuang.dao.UserDaoMysqlImpl" /> 
	//创建了一个UserDaoOrcalImpl对象，变量名为orcalImpl
<bean id="orcalImpl" class="com.kuang.dao.UserDaoOrcalImpl" />
    //创建了一个UserServiceImpl对象，变量名为serviceImpl
<bean id="serviceImpl" class="com.kuang.service.UserServiceImpl">
    <!--
        ref：引用Spring容器中创建好的对象
        value:具体的值，基本数据类型
    -->
    <property name="userDao" ref="mysqlImpl"/>
</bean>

测试类：

//获取 applicationcontext; 拿到spring容器
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//容器在手，天下我有，需要什么 就直接get什么！
UserServiceImpl serviceImpl = (UserServiceImpl) context.getBean("serviceImpl");
serviceImpl.getUser();

有参案例：

dao层：

public class User {
    private String name;

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public void show(){
        System.out.println("name=" + name);
    }
}

xml配置：

 <!-- 无参构造方法注入  -->
<!--    <bean id="user" class="com.kuang.pojo.User">-->
<!--        <property name="name" value="大娃"/>-->
<!--    </bean>-->

    <!-- 有参构造方法注入 index方式（下标赋值）   -->
<!--    <bean id="user" class="com.kuang.pojo.User">-->
<!--        <constructor-arg index="0" value="-有参构造"/>-->
<!--    </bean>-->

   <!-- 有参构造方法注入 直接通过参数名赋值 （最常用）   -->
    <bean id="user" class="com.kuang.pojo.User">
        <constructor-arg name="name" value="-name方式"/>
    </bean>

测试类：

public class MyTest {
    public static void main(String[] args) {
        //获取到容器
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        User user = (User) context.getBean("user");
        user.show();
    }
}

总结： 在配置文件加载的时候，容器中管理的对象就已经被初始化了！