Spring（2）Spring IOC详解

IOC（控制反转：Inverse ofControl ）
又称作依赖注入，是一种重要的面向对象编程的法则来削减计算机程序的耦合问题，
也是轻量级的 Spring 框架的核心

一，IOC实例

这里通过实例来讲解IOC
先写一个JavaWork.java：

public class JavaWork {
    ／／定义一个做测试的方法
    public void doTest(){
        ZhangSan zhangsan=new ZhangSan();
        zhangsan.test();
    }
}

写一个张三来做测试，ZhangSan.java:

public class ZhangSan {

    public void test(){
        System.out.println("张三-测试咯");
    }
}

最后建一个Test.java来执行任务：

public class Test {

    public static void main(String[]) args) {
        JavaWork javawork=new JavaWork();
        javawork.doTest();
    }
}

到这里张三的测试可以完整执行了，但是这时张三和业务完全耦合在一起，比如加一个测试员李四。这时代码要改很多，这是就提出了IOC设计思路。 改进过程如下：
1，定义一个Tester.java接口,接口里的抽象方法有test()
2，用到多态，张三和李四都继承Tester这个接口
3，JavaWork类中添加tester测试员，并对tester取一个set方法

public class JavaWork {

    private Tester tester;

    public void setTester(Tester tester) {
        this.tester = tester;
    }

    public void doTest(){
        /*ZhangSan zhangsan=new ZhangSan();
        zhangsan.test();*/
        tester.test();
    }
}

4，Test类中设置某个人做测试，这样控制权就交给了主管，也就是实现了控制反转。
控制反转（IOC）又称依赖注入，是一种重要的面向对象编程的法则来消减计算机程序的耦合性问题，也是轻量级的Spring框架的核心。

import com.java1234.service.JavaWork;
import com.java1234.service.Lisi;

public class Test {

    //主管执行命令
    public static void main(String[] args) {
        JavaWork javaWork=new JavaWork();
        // javaWork.setTester(new ZhangSan());
        javaWork.setTester(new Lisi());
        javaWork.doTest();
    }
}

当然，在Spring中，都是用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
        http://www.springframework.org/schema/beans/spring-beans.xsd">


    <bean id="zhangsan" class="com.java1234.service.ZhangSan"></bean>

    <bean id="lisi" class="com.java1234.service.Lisi"></bean>

    <bean id="javaWork" class="com.java1234.service.JavaWork">
        <!-- name对应javawork中的tester -->
        <property name="tester" ref="zhangsan"></property>
    </bean>

</beans>

对应的Test2如下：

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

import com.java1234.service.JavaWork;

public class Test2 {

    public static void main(String[] args) {
        //引入ApplicationContext容器来加载beans，并获取beans
        ApplicationContext ac=new ClassPathXmlApplicationContext("beans.xml");
        JavaWork javaWork=(JavaWork)ac.getBean("javaWork");
        javaWork.doTest();
    }
}

二，依赖注入

依赖注入常用的有属性注入，构造函数注入（通过类型，索引，两种联合使用），工厂方法注入（非静态工厂和静态工厂）三种方法。
这里就给例子了，大家可以自己研究下
这里写图片描述
People.java

package com.java1234.entity;

public class People {

    private int id;
    private String name;
    private int age;

    public People() {
        super();
    }

    public People(int id, String name, int age) {
        super();
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "People [id=" + id + ", name=" + name + ", age=" + age + "]";
    }
}

PeopleFactory.java

package com.java1234.factory;

import com.java1234.entity.People;

public class PeopleFactory {

    public People createPeople(){
        People p=new People();
        p.setId(7);
        p.setName("小七");
        p.setAge(77);
        return p;
    }
}

PeopleFactory2.java

package com.java1234.factory;

import com.java1234.entity.People;

public class PeopleFactory2 {

    public static People createPeople(){
        People p=new People();
        p.setId(8);
        p.setName("王八");
        p.setAge(88);
        return p;
    }
}

Test.java:

package com.java1234.test;

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

import com.java1234.entity.People;


public class Test {

    public static void main(String[] args) {
        ApplicationContext ac=new ClassPathXmlApplicationContext("beans.xml");
        People people=(People)ac.getBean("people");
        System.out.println(people);

        People people2=(People)ac.getBean("people2");
        System.out.println(people2);

        People people3=(People)ac.getBean("people3");
        System.out.println(people3);

        People people4=(People)ac.getBean("people4");
        System.out.println(people4);

        People people5=(People)ac.getBean("people5");
        System.out.println(people5);

        //工厂方法注入
        People people7=(People)ac.getBean("people7");
        System.out.println(people7);

        People people8=(People)ac.getBean("people8");
        System.out.println(people8);
    }
}

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="people" class="com.java1234.entity.People"></bean>

     <!-- 属性注入 -->
    <bean id="people2" class="com.java1234.entity.People">
        <property name="id" value="1"></property>
        <property name="name" value="张三"></property>
        <property name="age" value="11"></property>
    </bean>

    <!--     通过类型注入依赖 -->
    <bean id="people3" class="com.java1234.entity.People">
        <constructor-arg type="int" value="2"></constructor-arg>
        <constructor-arg type="String" value="李四"></constructor-arg>
        <constructor-arg type="int" value="22"></constructor-arg>
    </bean>

    <!--    通过索引注入依赖 -->
    <bean id="people4" class="com.java1234.entity.People">
        <constructor-arg index="0" value="3"></constructor-arg>
        <constructor-arg index="1" value="王五"></constructor-arg>
        <constructor-arg index="2" value="55"></constructor-arg>
    </bean>

    <!--   联合注入依赖 -->
    <bean id="people5" class="com.java1234.entity.People">
        <constructor-arg index="0" type="int" value="4"></constructor-arg>
        <constructor-arg index="1" type="String" value="招六"></constructor-arg>
        <constructor-arg index="2" type="int" value="66"></constructor-arg>
    </bean>

    <!-- 非静态工厂 -->
    <bean id="peopleFactory" class="com.java1234.factory.PeopleFactory"></bean>

    <bean id="people7" factory-bean="peopleFactory" factory-method="createPeople"></bean>

     <!-- 静态工厂 -->
    <bean id="people8" class="com.java1234.factory.PeopleFactory2" factory-method="createPeople"></bean>
</beans>

最后的注入的结果：
这里写图片描述

三，bean之间的关系和作用范围

bean之间的关系有继承依赖和引用
1，继承（张三和李四都继承于abstractPeople，但是李四对age属性进行了重写）

    <!-- 定义抽象类abstractPeople,并定义一些公共属性和方法 -->
    <bean id="abstractPeople" class="com.java1234.entity.People" abstract="true">
        <property name="className" value="高三5班"></property>
        <property name="age" value="19"></property>
    </bean>

    <!-- 张三继承abstractPeople；并且依赖与authority，但是id和name不一样-->
    <bean id="zhangsan" parent="abstractPeople">
        <property name="id" value="1"></property>
        <property name="name" value="张三"></property>
    </bean>

    <!-- 李四也继承abstractPeople，但对age属性进行了重写，李四引用了dog -->
    <bean id="lisi" parent="abstractPeople">
        <property name="id" value="2"></property>
        <property name="name" value="李四"></property>
        <property name="age" value="20"></property>
    </bean>

2，依赖
张三依赖于authority，只用先获取权限后才能定义自身的属性，依赖用depends-on

<!-- 张三继承abstractPeople；并且依赖与authority，但是id和name不一样-->
    <bean id="zhangsan" parent="abstractPeople" depends-on="autority">
        <property name="id" value="1"></property>
        <property name="name" value="张三"></property>
    </bean>

    <bean id="autority" class="com.java1234.service.Authority"></bean>

3，引用
这里定义dog，然后李四引用就可以了

<!-- 定义dog，并定义属性 -->
    <bean id="dog" class="com.java1234.entity.Dog">
        <property name="name" value="jack"></property>
    </bean>

    <bean id="lisi" parent="abstractPeople">
        <property name="id" value="2"></property>
        <property name="name" value="李四"></property>
        <property name="age" value="20"></property>
        <!-- 李四引用dog -->
        <property name="dog" ref="dog"></property>
    </bean>

以上是bean之间的三种关系，大家可以自己写实体和测试类来测试，方法比较多，最好用到JUnit插件。
bean的作用范围
1，singletonSpring ioc 容器中仅有一个 Bean 实例，Bean 以单例的方式存在；
2，prototype 每次从容器中调用 Bean 时，都返回一个新的实例；
4，session 同一个 HTTPSession 共享一个 Bean；
5，globalsession 同一个全局 Session 共享一个 Bean，一般用于 Portlet 应用环境；
6，application 同一个 Application 共享一个 Bean；

这里提到了六个作用范围，一般开发中只用到前面两个，大家可以自行验证。