Spring学习之Ioc

Ioc原理讲解：http://www.cnblogs.com/xdp-gacl/p/4249939.html

Ioc

　　IoC是一种编程思想，由主动编程变为被动接收。

　　也就是说，所有的组件都是被动的（passive），所有的组件初始化和调用都由容器负责。组件处在一个容器中，由容器负责管理。

　　Ioc容器实现了对象的生命周期管理，降低了组件间的耦合度，将耦合推迟到了配置文件中，实现了软件各层间的解耦。

Ioc控制反转

　　控制的内容：

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

　　反转：

　　　　正转指程序本身来创建，反转指程序本身不去创建对象，而变为被动接收的对象。

　　总结：

　　　　控制反转--别名（依赖注入）

　　　　　　　　依赖注入--Dependency Injection
　　　　　　　　　　依赖：指bean对象创建依赖于容器。Bean对象的依赖资源
　　　　　　　　　　注入：指bean对象依赖的资源由容器来设置和装配

　　　　以前对象是由程序本身来创建，使用Spring后，程序变为被动接收Spring创建好的对象。

　　　　即应用本身不负责依赖对象的创建及维护，而是由外部容器负责，这样控制权就由应用转移到了外部容器，控制权的转移就是所谓反转。

Spring Ioc搭建

　　

Ioc应用

　　1.项目数据库的切换

<?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:aop="http://www.springframework.org/schema/aop"
         xmlns:tx="http://www.springframework.org/schema/tx"
         xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">
    
    <!-- 数据库变换 -->
    <bean id="userdao_mysql" class="dao.UserDaoMysqlImpl"/>
    <bean id="userdao_oracle" class="dao.UserDaoOracleImpl"/>
</beans>

package test;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import dao.UserDao;

public class Test {
    public static void main(String[] args) {
        BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao_mysql = (UserDao)factory.getBean("userdao_mysql");
        userDao_mysql.add();
        UserDao userDao_oracle = (UserDao)factory.getBean("userdao_oracle");
        userDao_oracle.add();
    }
}

　　

　　2.类初始化赋值

　　　　

　　　　

<?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:aop="http://www.springframework.org/schema/aop"
         xmlns:tx="http://www.springframework.org/schema/tx"
         xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">
<!-- 类赋值 -->
    <bean id="user" class="entity.User">
        <property name="name" value="Tom2"/>
        
        <!-- 集合 -->
        <property name="users">
            <list>
                <value>Zhengbin1</value>
                <value>Zhengbin2</value>
            </list>
        </property>
    </bean>
    
    <!-- ref 用来引用类
         一个 教师 负责多个 学生 -->
    <bean id="teacher" class="entity.Teacher">
        <property name="user" ref="user"/>
    </bean>
</beans>

package test;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import entity.Teacher;
import entity.User;

public class Test1 {
    public static void main(String[] args) {
        BeanFactory beanFactory = new ClassPathXmlApplicationContext("applicationContext.xml");
        User u = (User)beanFactory.getBean("user");
        System.out.println(u.getName());
        System.out.println(u.getUsers());
        
        Teacher t = (Teacher)beanFactory.getBean("teacher");
        System.out.println(t.getUser().getName());
    }
}

　　输出：

　　　　

　　

　　3.Ioc的类初始化与单例模式

　　　　

　　　　

<?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:aop="http://www.springframework.org/schema/aop"
         xmlns:tx="http://www.springframework.org/schema/tx"
         xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">
    
<!-- scope 定义bean是否是单例
         如果为 singleton 则在 BeanFactory 作用范围内，只维护此Bean的一个实例
         如果为 prototype（原型） 则在 BeanFactory 将为每次Bean请求创建一个新的Bean实例 -->
    <bean id="clazz" class="entity.Clazz" lazy-init="true" scope="prototype">
        <property name="name" value="zhengbin"/>
    </bean>
</beans>

package test;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import entity.Clazz;

public class Test2 {
    public static void main(String[] args) {
//        Spring 默认情况下，在读取配置文件时，已经完成创建对象,提高了系统性能
        BeanFactory beanFactory = new ClassPathXmlApplicationContext("applicationContext.xml");
        System.out.println("--------------");
        Clazz c = (Clazz)beanFactory.getBean("clazz");
        Clazz c1 = (Clazz)beanFactory.getBean("clazz");
        System.out.println(c.getName());
        System.out.println(c1.getName());
        System.out.println(c==c1);
        c.setName("ZhengBin");
        System.out.println(c.getName() + "----" + c1.getName());
    }
}