IoC: 控制反转

:将传统的由程序代码直接操控对象的调用权交给容器.通过容器控制对象的装配及生命周期管理.

(一下这两段话摘自http://blog.csdn.net/m13666368773/article/details/7802126)

IOC中最基本的技术就是“反射(Reflection)”编程，目前.Net C#、Java和PHP5等语言均支持，其中PHP5的技术书籍中，有时候也被翻译成“映射”。有关反射的概念和用法，大家应该都很清楚，通俗来讲就是根据给出的类名（字符串方式）来动态地生成对象。这种编程方式可以让对象在生成时才决定到底是哪一种对象。反射的应用是很广泛的，很多的成熟的框架，比如象Java中的hibernate、Spring框架，.Net中 NHibernate、Spring.NET框架都是把“反射”做为最基本的技术手段。

我们可以把IOC容器的工作模式看做是工厂模式的升华，可以把IOC容器看作是一个工厂，这个工厂里要生产的对象都在配置文件中给出定义，然后利用编程语言的的反射编程，根据配置文件中给出的类名生成相应的对象。从实现来看，IOC是把以前在工厂方法里写死的对象生成代码，改变为由配置文件来定义，也就是把工厂和对象生成这两者独立分隔开来，目的就是提高灵活性和可维护性。

控制反转的两种实现方式:

1.依赖查找(DL)

2.依赖注入(DI): 程序在运行时,若需要调用另一个对象协助,无需在代码中创建而是依赖外部容器,由容器创建后传递给程序.

依赖注入是最优秀的解耦方式,依赖注入让Spring的bean 之间以配置文件方式组织在一起而不是硬编码的方式.

控制反转Demo1:
/*dao层接口*/
public interface IStudentDao {
    public void selectStudent(int cid);
}
/*dao层实现类*/
public class StudentDaoImpl implements IStudentDao {
    public StudentDaoImpl() {
        super();
        System.out.println("构造函数执行!");
    }
    @Override
    public void selectStudent(int cid) {
        System.out.println("查找学生"+cid);
    }
/*Sping配置文件中注册实现类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">
    <!-- bean definitions here -->
        <bean id="sdImpl" class="com.xiehe.dao.StudentDaoImpl"/>
</beans>
/*测试类中*/
public class MyTest {
    @Test
    public void test01(){
        //1.获取容器
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationSpring.xml");
        //2.从容器中获取对象
        IStudentDao sdImpl = (IStudentDao) context.getBean("sdImpl");
        sdImpl.selectStudent(1);
    }
 :结果截图

 本例中可以明显看出,在测试类中获取StudentDaoImpl 是通过容器(调用了构造)而不是依赖于StudentDaoImpl 
 

ApplicationContext 用于加载Spring 配置文件,在程序中充当容器.其实现类有两

a)基于xml的注入:

Bean的初始化由容器完成称为注入.根据注入方式不同分为 设值注入 和 构造注入

1)设值注入 : 通过setter 方法传入被调用者的实例中

2)构造注入 : 调用构造函数完成注入

/*实体类:schol*/
public class School {
    private String name;
    private String addr;
    public School(String name, String addr) {
        super();
        this.name = name;
        this.addr = addr;
    }
    public School() {
        super();
    }
Getter/setter
}
/*实体类:Student*/
public class Student {
    private String name;
    private int age;
    private School mySchool;
    public Student() {
        super();
    }
    public Student(String name, int age, School mySchool) {
        super();
        this.name = name;
        this.age = age;
        this.mySchool = mySchool;
    }
Getter/setter
}
/*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 definitions here -->
    <!-- 设值注入 -->
        <bean id="mySchool" class="com.xiehe.dao.School">
            <property name="name" value="北京大学"></property>
            <property name="addr" value="海淀区"></property>
        </bean>
        <!-- 设值注入 -->
        <bean id="sdImpl" class="com.xiehe.dao.Student" >
            <property name="name" value="张赛"/>
            <property name="age" value="58"/>
            <!-- 域类型注入方式1:-- >
            <!-- <property name="mySchool" ref="mySchool"/> -->
            <!-- 域类型注入方式2:-- >
            <property name="mySchool">
                <ref bean="mySchool"/>
            </property>
        </bean>
        <!-- 构造注入 -->
        <bean id="sdImpl2" class="com.xiehe.dao.Student">
            <constructor-arg name="name" value="张赛"/>
            <constructor-arg name="age" value="58"/>
            <constructor-arg name="mySchool" ref="mySchool"/>
        </bean>    
</beans>
/*测试类*/
public class MyTest {
    @Test
    public void test01(){
        //1.获取容器
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationSpring.xml");
        //2.从容器中获取对象(设值注入)
        Student dao = (Student) context.getBean("sdImpl");
        System.out.println(dao);    
    }
    @Test
    public void test02(){
        //1.获取容器
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationSpring.xml");
        //2.从容器中获取对象(构造注入)
        Student dao = (Student) context.getBean("sdImpl2");
        System.out.println(dao);    
    }
}

 

Test01 结果截图:
Test02 结果截图:

b)基于注解的注入:

     在Spring 配置文件中添加组件扫描器:

<context:component-scan base-package="com.xiehe.dao"/>

 在xml配置了这个标签后，spring可以自动去扫描base-pack下面或者子包下面的Java文件，如果扫描到有@Component (普通bean)@Controller(控制器)@Service(服务器)等这些注解的类，则把这些类注册为bean.

/*注解式注入 */
@Component("school1")
public class School {
    @Value("清华大学")
    private String name;
    @Value("海淀区")
    private String addr;
}
/*注解式注入*/
@Component(value="stu1")
public class Student {
    @Value("张嘴")
    private String name;
    @Value("44")
    private int age;
    //默认 byType
    @Autowired
    private School mySchool;
}
/*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"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- bean definitions here -->
    <!-- 配置组件扫描器 -->
    <context:component-scan base-package="com.xiehe.dao"/>    
</beans>    
/*测试类*/
public class MyTest {
    @Test
    public void test01(){
        //1.获取容器
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("com/xiehe/dao/applicationSpring.xml");
        //2.从容器中获取对象
        Student dao = (Student) context.getBean("stu1");
        System.out.println(dao);
    }
}

运行截图: