spring2.5IOC控制反转详解

spring2.5IOC控制反转详解

基本的代码结构

1 IOC包下

基本的spring创建对象

将类添加到配置文件中，由容器创建。

Source code    
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xsi:schemaLocation="http://www.springframework.org/schema/beans
  5. http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
  6. <!--
  7. 把HelloWorld这个类纳入spring容器
  8. id为bean的唯一标识
  9. 正规的写法：
  10. 类的第一个字母变成小写，其余不变
  11. class为类的全名
  12. -->
  13. <bean id="helloWorld" class="cn.itcast.spring0401.ioc.HelloWorld"></bean>
  14. </beans>

helloworld类

Source code    
  1. package cn.itcast.spring0401.ioc;
  2. public class HelloWorld {
  3. public void say(){
  4. System.out.println("hello");
  5. }
  6. }

测试类

这就是控制反转

Source code    
  1. package cn.itcast.spring0401.ioc;
  2. import org.junit.Test;
  3. import org.springframework.context.ApplicationContext;
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;
  5. /**
  6. * 控制反转
  7. * @author Administrator
  8. *
  9. */
  10. public class IOCTest {
  11. /**
  12. * 启动spring容器
  13. *         创建spring容器对象就相当于启动spring容器
  14. * spring容器做的工作：
  15. * * 创建对象
  16. */
  17. @Test
  18. public void testHelloWorld(){
  19. ApplicationContext context = new ClassPathXmlApplicationContext("cn/itcast/spring0401/ioc/applicationContext.xml");
  20. HelloWorld helloWorld = (HelloWorld)context.getBean("helloWorld");
  21. helloWorld.say();
  22. }
  23. }

2 alias包，别名

配置文件，可以给类起别名

Source code    
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xsi:schemaLocation="http://www.springframework.org/schema/beans
  5. http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
  6. <bean id="helloWorld" class="cn.itcast.spring0401.alias.HelloWorld"></bean>
  7. <!--
  8. name与bean中的id对应
  9. alias 名字
  10. -->
  11. <alias alias="狗蛋" name="helloWorld"/>
  12. <alias alias="王三麻子" name="helloWorld"/>
  13. </beans>

测试方法

Source code    
  1. package cn.itcast.spring0401.alias;
  2. import org.junit.Test;
  3. import org.springframework.context.ApplicationContext;
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;
  5. public class AliasTest {
  6. @Test
  7. public void test(){
  8. ApplicationContext context = new ClassPathXmlApplicationContext("cn/itcast/spring0401/alias/applicationContext.xml");
  9. HelloWorld helloWorld = (HelloWorld)context.getBean("王三麻子");
  10. helloWorld.say();
  11. }
  12. }

输出结果还是一样的。

3 createbean  创建对象的几种方法

* 利用默认的构造函数
* 利用静态工厂方法
* 利用实例工厂方法

配置文件

Source code    
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xsi:schemaLocation="http://www.springframework.org/schema/beans
  5. http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
  6. <bean id="helloWorld" class="cn.itcast.spring0401.createbean.HelloWorld"></bean>
  7. <!--
  8. -->
  9. <bean id="helloWorld1" class="cn.itcast.spring0401.createbean.HelloWorldFactory" factory-method="createBean"></bean>
  10. </beans>

工厂类

Source code    
  1. package cn.itcast.spring0401.createbean;
  2. public class HelloWorldFactory {
  3. /**
  4. * 工厂方法
  5. * @return
  6. */
  7. public static HelloWorld createBean(){
  8. return new HelloWorld();
  9. }
  10. }

helloworld

Source code    
  1. package cn.itcast.spring0401.createbean;
  2. public class HelloWorld {
  3. public void say(){
  4. System.out.println("hello");
  5. }
  6. public HelloWorld(){
  7. System.out.println("new helloworld");
  8. }
  9. }

测试类

Source code    
  1. package cn.itcast.spring0401.createbean;
  2. import org.junit.Test;
  3. import org.springframework.context.ApplicationContext;
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;
  5. public class CreateBeanTest {
  6. /**
  7. * 在HelloWorld中写如下代码
  8. *         public HelloWorld(){
  9. System.out.println("new helloworld");
  10. }
  11. 输出为："new helloworld"
  12. 说明
  13. * spring容器默认调用类的默认的构造器来创建对象的
  14. * 如果在HelloWorld中，没有默认的构造器，则spring在创建helloWorld对象时，会报错
  15. 因为找不到默认的构造器
  16. */
  17. @Test
  18. public void testConstructor(){
  19. ApplicationContext context = new ClassPathXmlApplicationContext("cn/itcast/spring0401/createbean/applicationContext.xml");
  20. HelloWorld helloWorld = (HelloWorld)context.getBean("helloWorld");
  21. helloWorld.say();
  22. }
  23. /**
  24. * spring容器做的事情：
  25. * * spring容器调用了工厂类的工厂方法
  26. * * 真正创建对象new HelloWorld()是由程序员来完成的
  27. */
  28. @Test
  29. public void testFactory(){
  30. ApplicationContext context = new ClassPathXmlApplicationContext("cn/itcast/spring0401/createbean/applicationContext.xml");
  31. HelloWorld helloWorld = (HelloWorld)context.getBean("helloWorld1");
  32. helloWorld.say();
  33. }
  34. }

4init包，创建对象的时机

默认情况下，在spring启动的时候，创建纳入spring容器中所有的bean
在spring容器启动的时候，可以检查错误
但是如果bean的属性中有数据，会过早的加载到内存中，所以如果bean中有数据
应该把数据的对象的声明放在方法中
* 如果在spring的配置文件中，有lazy-init为true，则context.getBean(“beanId”)时
才要创建对象
缺点：在spring容器启动的时候，是检验不出错误的

配置文件

Source code    
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xsi:schemaLocation="http://www.springframework.org/schema/beans
  5. http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
  6. <bean id="helloWorld" class="cn.itcast.spring0401.init.HelloWorl" lazy-init="true"></bean>
  7. </beans>

helloworld

Source code    
  1. package cn.itcast.spring0401.init;
  2. import java.util.ArrayList;
  3. import java.util.List;
  4. public class HelloWorld {
  5. public List<String> sList = new ArrayList<String>();
  6. public void say(){
  7. System.out.println("hello");
  8. }
  9. public HelloWorld(){
  10. System.out.println("aaa");
  11. }
  12. }

测试

Source code    
  1. package cn.itcast.spring0401.init;
  2. import org.junit.Test;
  3. import org.springframework.context.ApplicationContext;
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;
  5. public class InitTest {
  6. /**
  7. * * 在默认情况下，spring容器启动的时候，就把所有的纳入spring容器的bean创建对象
  8. * 缺点：
  9. *     如果一个对象中有属性，比如这个属性为集合，在创建这个对象的过程中，集合中有数据
  10. * 这样采用默认的启动形式，就会导致数据过早的加载到内存中
  11. * * 可以在spring的配置文件中：
  12. * <bean id="helloWorld" class=".." lazy-init="true">
  13. * 延迟bean的创建时间，在context.getBean时才要创建bean的对象
  14. * 如果spring的配置文件书写错误，如果所有的spring的bean都采用lazy-init="true"这种形式
  15. 则在启动web服务器的时候，发现不了spring容器的错误，这样是不利于排错的
  16. */
  17. @Test
  18. public void test(){
  19. ApplicationContext context = new ClassPathXmlApplicationContext("cn/itcast/spring0401/init/applicationContext.xml");
  20. HelloWorld helloWorld = (HelloWorld)context.getBean("helloWorld");
  21. helloWorld.say();
  22. }
  23. }

5scope 对象作用范围，单例多里

在配置文件中，scope为
“singleton”
* 默认值
* spring产生的bean只有一个实例
* 处于单例模式的bean的创建、初始化、销毁都是受spring容器管理的
* 在容器关闭的时候执行销毁工作
“prototype”
* 多例
* spring容器负责该bean的创建、初始化，但是销毁工作程序员做
* 无论该bean的lazy-init为什么值，都在context.getBean时创建对象
* 如果该bean中有资源对象，手动关闭

配置

Source code    
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xsi:schemaLocation="http://www.springframework.org/schema/beans
  5. http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
  6. <!--
  7. scope
  8. 决定bean的范围
  9. singleton 单例 默认
  10. prototype 原型 多例
  11. -->
  12. <bean id="helloWorld" class="cn.itcast.spring0401.scope.HelloWorld" scope="singleton"></bean>
  13. </beans>

测试

Source code    
  1. package cn.itcast.spring0401.scope;
  2. import org.junit.Test;
  3. import org.springframework.context.ApplicationContext;
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;
  5. public class ScopeTest {
  6. /**
  7. * 由spring容器产生的bean默认是单例模式
  8. * 在spring的配置文件中：
  9. *      scope:
  10. * singleton 默认的形式
  11. * 如果写默认的形式，一个集合或者一个数据出现在了类的属性中，这个数据将成为全局的数据(共享数据)，应该
  12. * 注意并发问题
  13. * 当spring容器中的bean是多例，则不管配置文件中的lazy-init为default、false还是true，在
  14. * context.getBean时才要为bean创建对象
  15. */
  16. @Test
  17. public void test(){
  18. ApplicationContext context = new ClassPathXmlApplicationContext("cn/itcast/spring0401/scope/applicationContext.xml");
  19. HelloWorld helloWorld = (HelloWorld)context.getBean("helloWorld");
  20. helloWorld.s.add("aaa");
  21. helloWorld.s.add("bb");
  22. HelloWorld helloWorld1 = (HelloWorld)context.getBean("helloWorld");
  23. helloWorld1.s.add("cc");
  24. System.out.println(helloWorld.s.size());
  25. }
  26. }

6initdestory

对象的初始化，销毁

配置文件

Source code    
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xsi:schemaLocation="http://www.springframework.org/schema/beans
  5. http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
  6. <!--
  7. init-method
  8. 对象的初始化方法
  9. destroy-method
  10. 对象的销毁方法
  11. -->
  12. <bean id="helloWorld" class="cn.itcast.spring0401.initdestroy.HelloWorld" init-method="init" destroy-method="destroy" scope="prototype"></bean>
  13. </beans>

测试

Source code    
  1. package cn.itcast.spring0401.initdestroy;
  2. import org.junit.Test;
  3. import org.springframework.context.ApplicationContext;
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;
  5. public class InitDestroyTest {
  6. /**
  7. * 在spring的配置文件中
  8. *     init-method="init"
  9. * 说明在创建完该对象后，立刻执行init方法，用来进行初始化
  10. * destroy-method="destroy"
  11. * * 当该bean为单例模式，才能调用该方法
  12. * destroy方法在容器销毁的时候被调用
  13. * * 当该bean为多例时，spring容器不负责他的销毁工作
  14. * * 如果该bean为多例时，当不用该bean时，应该手动销毁资源文件
  15. */
  16. @Test
  17. public void test(){
  18. ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("cn/itcast/spring0401/initdestroy/applicationContext.xml");
  19. HelloWorld helloWorld = (HelloWorld)context.getBean("helloWorld");
  20. helloWorld.say();
  21. context.destroy();//销毁spring容器
  22. }
  23. }

hello

Source code    
  1. package cn.itcast.spring0401.initdestroy;
  2. import java.util.ArrayList;
  3. import java.util.List;
  4. public class HelloWorld {
  5. public void say(){
  6. System.out.println("hello");
  7. }
  8. public void init(){
  9. System.out.println("init");
  10. }
时间： 2024-11-08 20:59:11

spring2.5IOC控制反转详解的相关文章

【框架】[Spring3]下载安装、开源框架与IoC控制反转详解

转载请注明出处:http://blog.csdn.net/qq_26525215 本文源自[大学之旅_谙忆的博客] 昨天刚刚初学Spring3,也许Spring3有点老了哈,不过还是先把3学了再去学习4吧,首先先介绍一下如何去下载Spring的必须包吧. (本篇博客适用于初学Spring的朋友) java spring4现在不推荐使用xml配置文件- 当然啦,这些知识点在Spring4还是可以用的. 不过我在这里详解的还是Spring3哈,见谅~ 下载SpringJAR包/文档: Spring官

重建控制文件详解

http://note.youdao.com/share/?id=d3991566cad33723db8b92183dcd9161&type=note 完整图文最新版 创造"重建控制文件脚本"需要在mount或open下进行. alter database backup controlfile to trace as '/tmp/ctl..sql'; 执行"重建控制文件脚本"需要在nomount的时候. -- The following are curren

x264码率控制总结3——码率控制参数详解

x264码率控制参数详解 -q, --qp <integer>          Force constant QP (0-51, 0=lossless) 默认:无 说明:三种可选的码率控制方法(bitrate, CQP,CRF)之一.设置x264使用固定QP模式.设定的QP将被作为P帧的量化参数,I帧和B帧的量化参数由–ipratio and –pbratio参数进一步算出.CQP模式使用固定的QP,这意味着最终的文件大小是不可知的.设置为0将产出无损输出.相同视觉质量时,CQP模式编码输出

php_ThinkPHP的RBAC（基于角色权限控制）详解

一.什么是RBAC 基于角色的访问控制(Role-Based Access Control)作为传统访问控制(自主访问,强制访问)的有前景的代替受到广泛的关注. 在RBAC中,权限与角色相关联,用户通过成为适当角色的成员而得到这些角色的权限.这就极大地简化了权限的管理. 在一个组织中,角色是为了完成各种工作而创造,用户则依据它的责任和资格来被指派相应的角色,用户可以很容易地从一个角色被指派到另一个角色.角色可依新的需求和系统的合并而赋予新的权限,而权限也可根据需要而从某角色中回收.角色与角色的关

现代JS中的流程控制：详解Callbacks 、Promises 、Async/Await

JavaScript经常声称是_异步_.那是什么意思?它如何影响发展?近年来这种方法有何变化? 请思考以下代码: result1 = doSomething1(); result2 = doSomething2(result1); 大多数语言都处理每一行同步.第一行运行并返回结果.第二行在第一行完成后运行无论需要多长时间. 单线程处理 JavaScript在单个处理线程上运行.在浏览器选项卡中执行时,其他所有内容都会停止,因为在并行线程上不会发生对页面DOM的更改;将一个线程重定向到另一个URL

Vim翻页控制命令详解

当我们再Linux中的Vim编辑器查看脚本时,按上下键查看是不是非常慢?这个时候就要用到我们的翻页快捷键了,快捷键命令如下: 整页翻页命令为:    Ctrl + f 键   f 的英文全拼为:forward: Ctrl + b 键  b 的英文全拼为:backWord: 翻半页命令为:      Ctrl + d 键  d 的英文全拼为:down: Ctrl + u 键  u 的英文全拼为:up: 直接查看该脚本的最后一行:输入:$,然后回车: 在键盘按下大写G : 在键盘按Shift + g

IOC详解

Ioc--控制反转详解(转载  http://www.cnblogs.com/qinqinmeiren/archive/2011/04/02/2151697.html) 本文转载与百度知道,简单例子让初学者很快对IoC有一个全面的了解....  首先想说说IoC(Inversion of Control,控制倒转).这是spring的核心,贯穿始终.所谓IoC,对于spring框架来说,就是由spring来负责控制对象的生命周期和对象间的关系.这是什么意思呢,举个简单的例子,我们是如何找女朋友的

Laravel 控制反转和门面模式概念详解

Laravel 控制反转和门面模式概念详解 这两个概念对于 Laravel 的使用者来说应该并不陌生,尤其是当你希望扩展或者替换 Laravel 核心库的时候,理解和合理使用它们可以极大提升 Laravel 的战斗力.这里以创建一个自己的 ServiceProvider 为例理解 Inversion of Control 和 Facade 在 Laravel 中的应用. 控制反转(Inversion of Control) 什么是 IoC 控制反转(Inversion of Control,缩写

C#依赖注入控制反转IOC实现详解

原文:C#依赖注入控制反转IOC实现详解 IOC的基本概念是:不创建对象,但是描述创建它们的方式.在代码中不直接与对象和服务连接,但在配置文件中描述哪一个组件需要哪一项服务.容器负责将这些联系在一起. 举个例子,组件A中有类ClassA,组件B中有接口IB和其对应的实现类B1和B2. 那么,现在ClassA需要利用IB接口来做一些事情,例如: public class ClassA { public void DoSomething() { IB b = ??? b.DoWork(); }} 现