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

巴特西

Spring学习之Ioc

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

Ioc

Ioc控制反转

Spring Ioc搭建

Ioc应用

最新文章

热门文章