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>

applicationContext.xml

 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();
     }
 }

Test.java

　　

　　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>

applicationContext.xml

 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());
     }
 }

Test1.java

　　输出：

　　　　

　　

　　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>

applicationContext.xml

 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());
     }
 }

Test2.java