- 浏览: 1590133 次
- 来自: 上海
文章分类
- 全部博客 (374)
- Java (101)
- Struts (54)
- Oracle (30)
- JavaScript (16)
- Spring (27)
- Hibernate (16)
- MyEclipse (3)
- JSF (1)
- FreeMarker (2)
- SiteMesh (2)
- JfreeChart (2)
- Ibatis (2)
- JSP (12)
- MyBatis (4)
- SWFupload (1)
- EJB (4)
- Jboss (4)
- WebService (2)
- Linux (16)
- Android (2)
- XML (6)
- Java 网络编程 (13)
- AXIS2 (1)
- FTP (1)
- Jswing (1)
- Socket (3)
- 杂文选集 (6)
- solr (2)
- PS (1)
- Tomcat (7)
- JDBC (9)
- Highcharts (1)
- maven (1)
- Nodejs (0)
- navicat (2)
- Exception (5)
- eclipse (3)
- jQuery (1)
- springMVC (4)
- MySQL (11)
- SVN (1)
- Sql Server (1)
- zookeeper (1)
- JVM (1)
- Groovy (2)
- Git (1)
- Nginx (1)
- DynamicReport (1)
- IDEA (2)
- JasperReports (1)
- Postgresql (2)
- Mac (1)
- gradle (1)
- 数据结构算法 (1)
最新评论
-
hpu145:
引用引用
java 千分位的添加和去除 -
被遗忘的下路:
少了个junit-4.8.2的包
SSH2整合完整案例(四十三) -
白天看黑夜:
java过滤emoji字符处理,希望能帮到你http://ww ...
emoji 表情图片解决方法 -
caipeiming:
这个挺好JavaScript实现input输入框控件只允许输入 ...
js 控制文本框只能输入中文、英文、数字等 -
双子树:
东西太好啦受教啊
Struts2 JSP中将list,set ,Map传递到Action然后<s:iterator>遍历(三十五)
目录
1.spring 实例化 bean 的几种方式
2.spring 中bean 的作用域
3.spring 管理的bean 在什么时候初始化 和 销毁
4.spring bean 的 init-method destroy-method
1.下面 我们来看看spring的 实例化bean的 几种方式
1.使用类构造器实例化bean
2 使用 静态工厂方法来实例化
3. 使用 实例工厂方式来实例化bean
//测试
2.弄了这么多 那么spring 中每次 getBean();这个方法返回的对象 是同一个吗??
//以上 说明 是同一个对象 ,说明了spring 默认 的bean 是 单例模式 Singleton
spring bean 的作用域 scope
Singleton
prototype:每次从容器获取的bean 都是一个新的对象. (原型)
//对于 web 应用来说
request
session
global session
//修改spring 配置 来测试
//说明 设置 scope="prototype" 后变成了 原型 每次 获取都是不同的对象
3.看看 spring 在什么时候 初始化bean (在 配置 的bean对应的类中 加个 构造方法 就可以测试了)
1 先测试 singleton 范围
// 发现 打印 出了 "我被实例化了!" 说明 spring 默认情况下 是加载 spring配置文件的时候就初始化了 bean
2.在来测试 scope="prototype"
// 发现 打印出 "开始调用 getBean方法" 之后 才打印出 "我被实例化了!" "我被实例化了!"
// 说明 scope="prototype" 是在 getBean方法后 才被实例化
3.再来看延迟初始化 lazy-init="true";
// 发现 打印出 "开始调用 getBean方法" 之后 才打印出 "我被实例化了!"
说明 lazy-init="true" 也是在 getBean方法后才被初始化 但是 使用的是同一个对象 所以 只打印出了一句 "我被实例化了!" .而scope="prototype" 是原型 所以 打印出了 两句 "我被实例化了!" .
4.如果 我们想在 spring 初始化bean实例后 执行一个方法 , 或者 在 bean销毁后 执行一个方法 (比如 资源的打开 和 使用完后 资源的关闭:写到这 大家是不是 就想到了 打开数据库连接 和 关闭呀)
使用 这两个属性 init-method , destroy-method
// 发现 init 和 destroy 方法 都执行了
1.spring 实例化 bean 的几种方式
2.spring 中bean 的作用域
3.spring 管理的bean 在什么时候初始化 和 销毁
4.spring bean 的 init-method destroy-method
1.下面 我们来看看spring的 实例化bean的 几种方式
1.使用类构造器实例化bean
<!--1.使用类构造器实例化bean---> <bean id="personService" class="com.person.service.impl.PersonServiceBean"> </bean>
2 使用 静态工厂方法来实例化
<!-- 2.使用 静态工厂方法来实例化 bean --> <bean id="personService2" class="com.person.service.impl.PerssonServiceFactory" factory-method="createPersonService"/>
package com.person.service.impl; import com.person.service.PersonService; public class PerssonServiceFactory { //使用这个工厂中的静态方法 public static PersonService createPersonService(){ return new PersonServiceBean(); } }
3. 使用 实例工厂方式来实例化bean
<!-- 使用 实例工厂方式来实例化bean --> <bean id="perssonServiceFactory" class="com.person.service.impl.PerssonServiceFactory"/> <bean id="personService3" factory-bean="perssonServiceFactory" factory-method="createPersonService2"/>
package com.person.service.impl; import com.person.service.PersonService; public class PerssonServiceFactory { //使用 静态工厂方法来实例化 bean public static PersonService createPersonService(){ return new PersonServiceBean(); } //使用 实例工厂方式来实例化bean public PersonService createPersonService2(){ return new PersonServiceBean(); } }
//测试
@Test public void init3(){ ApplicationContext ctx=new ClassPathXmlApplicationContext("classpath:applicationContext.xml"); //方法一 获取服务层对象 PersonService personService=(PersonService)ctx.getBean("personService2"); //方法二 PersonService personService1=ctx.getBean("personService3",PersonService.class); personService.save(); personService1.save(); }
2.弄了这么多 那么spring 中每次 getBean();这个方法返回的对象 是同一个吗??
@Test //测试 spring 容器中的 bean 的作用域 public void init4(){ ApplicationContext ctx=new ClassPathXmlApplicationContext("classpath:applicationContext.xml"); //方法一 获取服务层对象 PersonService personService=(PersonService)ctx.getBean("personService"); PersonService personService1=(PersonService)ctx.getBean("personService"); //方法二 PersonService personService2=ctx.getBean("personService",PersonService.class); System.out.println(personService==personService1); //true System.out.println(personService1==personService2); //true }
//以上 说明 是同一个对象 ,说明了spring 默认 的bean 是 单例模式 Singleton
spring bean 的作用域 scope
Singleton
在每个Spring IOC容器中一个bean的定义只有一个对象实例,默认情况下,会在容器服务器启动时初始化bean,但我们可以制定Bean 节点 lazy-init="true" 来延迟初始化bean,这个时候,只有第一个获取bean才会初始化bean.如: <bean id="XXX" class="com.person.serivce.impl.PersonServiceBean" lazy-init="true"/> 如果 相对 spring文件中的所有bean 都 延迟初始化,可以在根节点beans 设置 default-lazy-init="true" 如下: <beans default-init="true"/>
prototype:每次从容器获取的bean 都是一个新的对象. (原型)
//对于 web 应用来说
request
session
global session
//修改spring 配置 来测试
<!-- 使用 静态工厂方法来实例化 bean 加入 scope 范围--> <bean id="personService2" class="com.person.service.impl.PerssonServiceFactory" factory-method="createPersonService" scope="prototype"/>
@Test //测试 spring 容器中的 bean 的作用域 public void init5(){ ApplicationContext ctx=new ClassPathXmlApplicationContext("classpath:applicationContext.xml"); //方法一 获取服务层对象 PersonService personService=(PersonService)ctx.getBean("personService2"); PersonService personService1=(PersonService)ctx.getBean("personService2"); //方法二 PersonService personService2=ctx.getBean("personService2",PersonService.class); System.out.println(personService==personService1); //false System.out.println(personService1==personService2); //false }
//说明 设置 scope="prototype" 后变成了 原型 每次 获取都是不同的对象
3.看看 spring 在什么时候 初始化bean (在 配置 的bean对应的类中 加个 构造方法 就可以测试了)
1 先测试 singleton 范围
package com.person.service.impl; import com.person.service.PersonService; public class PersonServiceBean implements PersonService { //测试 spring 在什么时候初始化 bean public PersonServiceBean() { System.out.println("我被实例化了!"); } public void save(){ System.out.println("我就是save方法!"); } }
@Test //测试 spring的 初始化 public void init(){ ApplicationContext ctx=new ClassPathXmlApplicationContext("classpath:applicationContext.xml"); }
// 发现 打印 出了 "我被实例化了!" 说明 spring 默认情况下 是加载 spring配置文件的时候就初始化了 bean
2.在来测试 scope="prototype"
@Test //测试 spring的 初始化 public void init(){ ApplicationContext ctx=new ClassPathXmlApplicationContext("classpath:applicationContext.xml"); System.out.println("开始调用 getBean方法"); //方法一 获取服务层对象 PersonService personService=(PersonService)ctx.getBean("personService"); //方法二 PersonService personService1=ctx.getBean("personService",PersonService.class); //personService.save(); //personService1.save(); }
// 发现 打印出 "开始调用 getBean方法" 之后 才打印出 "我被实例化了!" "我被实例化了!"
// 说明 scope="prototype" 是在 getBean方法后 才被实例化
3.再来看延迟初始化 lazy-init="true";
<!-- 使用 延迟初始化 --> <bean id="personService" class="com.person.service.impl.PersonServiceBean" lazy-init="true"> </bean>
@Test //测试 spring的 初始化 public void init(){ ApplicationContext ctx=new ClassPathXmlApplicationContext("classpath:applicationContext.xml"); System.out.println("开始调用 getBean方法"); //方法一 获取服务层对象 PersonService personService=(PersonService)ctx.getBean("personService"); //方法二 PersonService personService1=ctx.getBean("personService",PersonService.class); //personService.save(); //personService1.save(); }
// 发现 打印出 "开始调用 getBean方法" 之后 才打印出 "我被实例化了!"
说明 lazy-init="true" 也是在 getBean方法后才被初始化 但是 使用的是同一个对象 所以 只打印出了一句 "我被实例化了!" .而scope="prototype" 是原型 所以 打印出了 两句 "我被实例化了!" .
4.如果 我们想在 spring 初始化bean实例后 执行一个方法 , 或者 在 bean销毁后 执行一个方法 (比如 资源的打开 和 使用完后 资源的关闭:写到这 大家是不是 就想到了 打开数据库连接 和 关闭呀)
package com.person.service.impl; import com.person.service.PersonService; public class PersonServiceBean implements PersonService { //初始化后 执行的方法 public void init(){ System.out.println("打开数据库的连接"); } //销毁后执行的方法 public void destroy(){ System.out.println("关闭 数据的连接资源"); } //测试 spring 在什么时候初始化 bean public PersonServiceBean() { System.out.println("我被实例化了!"); } public void save(){ System.out.println("我就是save方法!"); } }
使用 这两个属性 init-method , destroy-method
<!-- 使用个 实例工厂方式来实例化bean --> <bean id="perssonServiceFactory" class="com.person.service.impl.PerssonServiceFactory"/> <bean id="personService3" factory-bean="perssonServiceFactory" factory-method="createPersonService2" init-method="init" destroy-method="destroy"/>
@Test //测试 spring 的 init-method , destroy-method public void init6(){ //注意这里 ApplicationContext 接口 没有 close 方法 只有 用 父接口 AbstractApplicationContext ctx=new ClassPathXmlApplicationContext("classpath:applicationContext.xml"); //方法二 PersonService personService1=ctx.getBean("personService3",PersonService.class); personService1.save(); ctx.close(); }
// 发现 init 和 destroy 方法 都执行了
发表评论
-
spring-session 中的坑
2017-07-06 15:34 9996spring-session 配置 依赖 gradle ... -
Spring AspectJ Aop Annotation
2017-03-29 17:08 709import org.aspectj.lang.Proce ... -
spring 第13天 使用@scheduled注解执行定时任务
2015-01-06 23:11 54085我们使用spring的注解 @Scheduled 执行定时任务 ... -
Spring 第12天,事务传播属性和 隔离级别
2014-09-28 00:36 8171 事务的传播属性(Propagation) 1) REQ ... -
spring 第11天 quartz任务调度
2014-08-24 13:59 1146Quartz是一个强大的企业级任务调度框架,Spring中继承 ... -
spring 第10 天 AOP 面向切面
2014-08-21 00:08 1753AOP(Aspect Orient Programming ... -
spring 第9天 Resurce 资源访问
2014-08-17 22:20 1868Spring Resource接口 spring提供的Reso ... -
spring 第8天 Spring 注解
2014-08-17 15:33 1472spring注解 @Component:标注一个普通的sp ... -
spring 第7天 Bean,BeanFactory处理器,配置器
2014-08-16 21:46 1238spring 两种后处理器 第一种,Bean 后处理器 对容器 ... -
spring 第6天SpEL,P命名空间,Util Schema
2014-08-13 22:52 1316使用p名称空间配置属性 ... -
spring 第5天不同作用域的bean,注入Field,方法返回值
2014-08-11 22:31 2114协调作用域不同步的bean 问题是;当一个singleton的 ... -
spring 第4天bean继承,init,destory-method
2014-08-10 17:54 1654深入理解Spring容器中的b ... -
spring 第3天使用java类和XML配置bean
2014-08-09 16:51 1506下面采用java类来配置bean,前面都采用xml进行配置be ... -
spring 第2天,bean作用域,自动注入集合
2014-08-06 22:16 1933sping容器中的Bean <!---beans的全 ... -
spring 第1天 IOC,DI,国际化,容器事件
2014-08-04 21:27 13951.构造注入(就是使用 构 ... -
SpringMVC 注解 和非注解
2014-01-26 10:29 18018首先看看非注解的项目结构 在web.xml文件 配置spr ... -
详解spring 每个jar的作用
2013-11-19 23:54 3912spring.jar 是包含有完整 ... -
Spring配置Hibernate事务
2013-11-10 13:45 1218为了保证数据的一致性,在编程的时候往往需要引入事务这个概念。事 ... -
Spring 中引用Properties文件
2013-08-29 14:39 10657其中部分配置信息(邮件发送相关): #邮件发送的相关配置 ... -
Spring IOC控制反转 依赖注入DI
2012-12-15 09:37 2330目录 1.使用IOC控制反转 中的DI依赖注入 手工注入 ...
相关推荐
Spring框架是Java企业级应用开发的事实标准,它通过依赖注入(DI)和面向切面编程(AOP)来...需要注意的是,无论是哪种方式,理解Spring Bean管理的原理和生命周期,对于开发高质量的Java企业级应用都是必不可少的。
Spring Bean 管理注解方式代码实例 Spring Bean 管理注解方式代码实例是 Spring 框架中的一种常见的 Bean 管理方式。通过使用注解的方式,可以简化 Bean 的配置和管理过程。这篇文章将详细介绍 Spring Bean 管理...
- **XML配置**:在传统的Spring应用中,Bean的定义通常写在XML配置文件中,如`springbean-xml`中的配置。 - **注解配置**:使用`@Component`,`@Service`,`@Repository`和`@Controller`注解标记类,配合`@...
在本文中,我们将深入探讨Spring框架中的Bean XML配置,这是Spring的核心特性之一,它允许我们定义、管理和装配应用中的对象。我们将围绕以下知识点展开: 1. **Spring框架基础**: Spring是一个开源的Java平台,...
整个流程中,Spring不仅创建了Bean,还管理了Bean的生命周期,包括依赖注入、初始化和销毁等。这种自动化管理使得开发者可以专注于业务逻辑,而不用关心对象的创建和管理细节。Spring的IoC容器使得应用更加灵活和...
在Spring框架中,Bean的生命周期管理是其核心特性之一,然而有时我们可能会遇到Spring Bean重复执行两次的问题,即实例被构造两次。这个问题可能是由多种原因引起的,涉及到Spring的初始化过程和容器的行为。以下是...
SpringBean是Spring框架的核心概念之一,它是Spring IoC容器管理的对象。在普元EOS平台中,SpringBean同样扮演着重要角色,用于封装业务逻辑、数据访问等功能。通过合理地设计和配置SpringBean,可以极大地提高开发...
总的来说,Spring Bean生命周期的理解和灵活运用,能帮助我们更好地控制Bean的行为,实现更高效、更可控的依赖管理和资源管理。通过深入学习源码,我们可以进一步了解Spring如何实现这些功能,从而提升我们的开发...
在Spring中,核心概念之一就是Bean,它是一个简单的Java对象,由Spring IoC容器管理。Spring通过XML配置文件或注解来定义、配置和管理Beans。下面将深入探讨`<beans>`、`<bean>`及其属性,以及其他相关的配置元素。 ...
在Spring框架中,bean的实例化是其核心功能之一,它允许我们管理应用程序中的对象生命周期。本篇将详细探讨两种工厂方法——实例工厂方法和静态工厂方法,用于创建Spring Bean。 首先,我们要理解Spring Bean的概念...
在 Spring Boot 应用程序中,SpringApplication 负责加载和管理 Bean。 SpringApplication 初始化 在 SpringApplication 运行之前,首先需要初始化 SpringApplication 实例。这个过程中,SpringApplication 会创建...
对于Prototype作用域的Bean,Spring不会自动管理销毁,需要由用户负责。 在实际应用中,理解这些步骤有助于优化Bean的加载和管理,避免依赖问题,提高应用性能。例如,通过调整Bean的加载顺序,可以控制某些服务的...
java *spring工具类 方便在非spring管理环境中获取beanjava *spring工具类 方便在非spring管理环境中获取beanjava *spring工具类 方便在非spring管理环境中获取beanjava *spring工具类 方便在非spring管理环境中获取...
在Spring框架中,Bean的生命周期管理是其核心特性之一,它允许开发者控制Bean从创建到销毁的整个过程。本资源提供了在Spring 4.2环境下关于Bean生命周期的测试代码,帮助我们深入理解这一关键概念。 首先,让我们...
SpringBean的生命周期.mdj
主要介绍了Spring Bean基本管理,以实例形式较为详细的分析了Spring Bean的相关使用技巧,具有一定参考借鉴价值,需要的朋友可以参考下
Spring通过IoC(Inversion of Control,控制反转)和DI(Dependency Injection,依赖注入)来管理这些Bean。在这个"Spring Bean简单应用实例"中,我们将深入理解这两个概念以及如何在实际应用中使用它们。 首先,...
在Spring中,Bean是应用中的对象,它们由Spring IoC容器负责创建、管理和装配。Bean配置是定义这些对象如何被创建和如何相互关联的过程。 **IoC(Inversion of Control)和DI(Dependency Injection)**: IoC是...
在Spring框架中,Bean的实例化顺序是一个关键概念,它涉及到如何管理和协调多个Bean的创建与依赖关系。这里,我们主要探讨的是Spring如何通过其IoC(Inversion of Control)容器来实例化Bean,并理解其背后的逻辑。 ...
在Spring框架中,Bean的管理是其核心特性之一,它涉及到Bean的创建、初始化、装配以及销毁等整个生命周期过程。本课件主要涵盖了以下几个关键知识点: 1. **控制反转(IoC)和依赖注入(DI)**:Spring的核心设计...