spring三种实例化Bean的方式和管理Bean的作用域和Bean的生命周期
Spring实例化Bean的三种方式分别是:
1,xml配置使用bean的类构造器
<bean id="personService" class="cn.service.impl.PersonServiceBean"></bean>
2,xml配置+factory类,使用静态工厂方法实例化
<bean id="personService2" class="cn.service.impl.PersonServiceBeanFactory" factory-method="createPersonServiceBean"/>
3,xml配置+factory类,使用实例工厂方法实例化
<bean id="personServiceFactory" class="cn.service.impl.PersonServiceBeanFactory"/>
<bean id="personService3" factory-bean="personServiceFactory" factory-method="createPersonServiceBean2"/>
三种Spring实例化Bean方法的用处,
第一种方法,通过bean的缺省构造函数创建,当各个bean的业务逻辑相互比较独立的时候或者和外界关联较少的时候可以使用。
第二种方法,利用静态factory方法创建,可以统一管理各个bean的创建,如各个bean在创建之前需要相同的初始化处理,则可用这个factory方法险进行统一的处理等等。
第三种方法,利用实例化factory方法创建,即将factory方法也作为了业务bean来控制。
Bean的作用域:
1,默认:singleton(单例,每次getBean()都是相同的Bean)
<bean id="bean1" class="cn.transaction.Bean1"></bean>
2,prototype:(每次getBean()都会获得新的Bean)
<bean id="bean1" class="cn.transaction.Bean1" scope="prototype"></bean>
Bean的生命周期:
1,默认:singleton 在容器实例化的时候就会实例化;
1.1,更该实例化时间:
<bean id="bean1" class="cn.transaction.Bean1" lazy-init="true"></bean>
如果要为所有的Bean延迟初始化:
在beans中配置该属性
1.2,配置初始化方法:
<bean id="bean1" class="cn.transaction.Bean1" lazy-init="true" init-method="init"></bean>
1.3,配置销毁方法
<bean id="bean1" class="cn.transaction.Bean1" lazy-init="true" init-method="init" destroy-method="destroy"></bean>
1.4,bean在什么时候被销毁
默认既然是在spring容器初始化时创建Bean,所以是Bean是在spring容器关闭的时候销毁。
2,prototype:在调用getBean()的时候进行实例化;
-----------------------------------------------------------------------------------------------------------------
spring学习,理解控制反转和spring在项目中可以带来的好处
今天开始学习Spring容器,是黎活明老师讲的,黎老师对Spring的研究非常透彻,讲了Spring容器功能实现的原理,它的控制翻转和面向切面,Spring在项目中使用带来的好处,并对一般Spring轻量级 ,重量级的错误认识进行了更正。
Spring是一个开源的控制反转(Inversion of Control ,IoC)和面向切面(AOP)的容器框架.它的主要目得是简化企业开发.
1 首先要理解控制反转的概念,如下面的程序
public class PersonServiceBean {
private PersonDao personDao = new PersonDaoBean();
public void save(Person person){
personDao.save(person);
}
}
PersonDao 就是依赖对象的类,PersonDaoBean 是在应用内部创建及维护的。所谓控制反转就是应用本身不负责依赖对象的创建及维护,依赖对象的创建及维护是由外部容器负责的。这样控制权就由应用转移到了外部容器,控制权的转移就是所谓反转
2把依赖对象交给外部容器负责创建,那么PersonServiceBean 类可以改成如下:
public class PersonServiceBean {
private PersonDao personDao ;
//通过构造器参数,让容器把创建好的依赖对象注入进PersonServiceBean,当然也可以使用setter方法进行注入。
public PersonServiceBean(PersonDao personDao){
this.personDao=personDao;
}
public void save(Person person){
personDao.save(person);
}
}
所谓依赖注入就是指:在运行期,由外部容器动态地将依赖对象注入到组件中。
3.黎老师对spring在项目中可以带来下面的好处进行了总结。
1)降低组件之间的耦合度,实现软件各层之间的解耦。
Controller——>Service——>DAO
2)可以使用容器提供的众多服务,如:事务管理服务、消息服务等等。当我们使用容器管理事务时,开发人员就不再需要手工控制事务.也不需处理复杂的事务传播。
3)容器提供单例模式支持,开发人员不再需要自己编写实现代码。
4)容器提供了AOP技术,利用它很容易实现如权限拦截、运行期监控等功能。
5)容器提供的众多辅作类,使用这些类能够加快应用的开发,如: JdbcTemplate、 HibernateTemplate。
6)Spring对于主流的应用框架提供了集成支持,如:集成Hibernate、JPA、Struts等,这样更便于应用的开发。
7) 使用spring容器可以提供的服务:事务管理服务,JMS服务,Spring Core核心服务,持久化服务等。
8)如果使用Spring, 我们就不再需要手工控制事务,例如在Hibernate中控制事务的语句 session.beginTransaction(); session.getTransaction().commit();
9)使用Spring,不再需要我们处理复杂的事务传播行为。
经常有人分不清spring属于轻量级框架,还是重量框架?有些人认为一个项目超过10M就是重量级的,这种划分很明显是错误的,因为有可能它包含了大部分的图片,而只含有很少的代码。其实划分一个应用是否属于轻量级还是重量级,主要看它使用了多少服务.使用的服务越多,容器要为普通java对象做的工作就越多,必然会影响到应用的发布时间或者运行性能.
对于spring容器,它提供了很多服务,但这些服务并不是默认为应用打开的,应用需要某种服务,还需要指明使用该服务,如果应用使用的服务很少,如:只使用了spring核心服务,那么我们可以认为此时应用属于轻量级的,如果应用使用了spring提供的大部分服务,这时应用就属于重量级。目前EJB容器就因为它默认为应用提供了EJB规范中所有的功能,所以它属于重量级。
---------------------------------------------------------------------------------------------------------------------
实例化bean的方式及Bean的作用域
继续学习Spring,黎老师对Spring研究比较透彻,讲课思路很清晰,认真听讲很容易理解。黎老师对Spring中比较重要的部分都进行了讲解,实例化Spring容器的方式,实例化bean的方式,Bean的作用域等。并进行了举例,通过对Spring和以前项目的学习,在项目中可以使用Sping,使项目功能的实现更简单,遵循MVC模式。
使用Spring需要的jar
可以到http://www.springsource.org/download下载spring,然后进行解压缩,在解压目录中找到下面jar文件,拷贝到类路径下
dist/spring.jar
lib/jakarta-commons/commons-logging.jar
如果使用了切面编程(AOP),还需要下列jar文件
lib/aspectj/aspectjweaver.jar和aspectjrt.jar
lib/cglib/cglib-nodep-2.1_3.jar
如果使用了JSR-250中的注解,如@Resource/@PostConstruct/@PreDestroy,还需要下列jar文件
lib/j2ee/common-annotations.jar
beans.xml 的配置模板
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
.....
</beans>
该配置模版可以从spring的参考手册或spring的例子中得到。配置文件的取名可以任意,文件可以存放在任何目录下,但考虑到通用性,一般放在类路径下。
实例化Spring容器常用的两种方式:
方法一:
在类路径下寻找配置文件来实例化容器
ApplicationContext ctx = new ClassPathXmlApplicationContext(new String[]{"beans.xml"});
方法二:
在文件系统路径下寻找配置文件来实例化容器
ApplicationContext ctx = new FileSystemXmlApplicationContext(new String[]{“d://beans.xml“});
一般使用第一种方式,Spring的配置文件可以指定多个,可以通过String数组
传入。
当spring容器启动后,因为spring容器可以管理bean对象的创建,销毁等生命
周期,所以我们只需从容器直接获取Bean对象就行,而不用编写一句代码来创建
bean对象。从容器获取bean对象的代码如下:
ApplicationContext ctx = new ClassPathXmlApplicationContext(“beans.xml”);
OrderService service = (OrderService)ctx.getBean("personService");
三种实例化bean的方式:
1.使用类构造器实例化
<bean id=“orderService" class="cn.itcast.OrderServiceBean"/>
2.使用静态工厂方法实例化
<bean id="personService" class="cn.itcast.service.OrderFactory" factory-method="createOrder"/>
public class OrderFactory {
public static OrderServiceBean createOrder(){
return new OrderServiceBean();
}
}
3.使用实例工厂方法实例化:
<bean id="personServiceFactory" class="cn.itcast.service.OrderFactory"/>
<bean id="personService" factory-bean="personServiceFactory" factory-method="createOrder"/>
public class OrderFactory {
public OrderServiceBean createOrder(){
return new OrderServiceBean();
}
}
Bean的作用域
.singleton (单例)
在每个Spring IoC容器中一个bean定义只有一个对象实例。默认情况下会在容器启动时初始化bean,但我们可以指定Bean节点的lazy-init=“true”来延迟初始化bean,这时候,只有第一次获取bean会才初始化bean。如:
<bean id="xxx" class="cn.itcast.OrderServiceBean" lazy-init="true"/>
如果想对所有bean都应用延迟初始化,可以在根节点beans设置default-lazy-init=“true“,如下:
<beans default-lazy-init="true“ ...>
实际应用中不把这个属性设置为true.
.prototype (原型)
每次从容器获取bean都是新的对象。每次调用getBean方法,都获取新的实例。
调用调用getBean方法时 bean才实例化
.request
.session
.global session
在配置文件中指定Bean的初始化方法和销毁方法
<bean id="xxx" class="cn.itcast.OrderServiceBean" init-method="init" destroy-method="close"/>
Bean实例化后 ,就会执行init方法, Spring容器通过反射机制来调用。
AbstractApplicationContext ctx=new ClassPathXmlApplicationContext("beans.xml");
ctx.close();//正常关闭spring容器。
相关推荐
通过上述介绍,我们可以看出Spring IOC控制反转的核心思想是将对象的创建和管理交给了Spring容器,从而实现了组件间的解耦。这种方式极大地提高了代码的可维护性和扩展性,是现代Java开发中不可或缺的一部分。
在Spring框架中,控制反转主要通过两种方式实现:构造器注入和setter注入。构造器注入是在创建对象时通过构造函数传入依赖,而setter注入则是在对象创建后通过setter方法设置依赖。这两种方式都可以帮助我们解耦代码...
在软件开发中,控制反转(Inversion of Control,简称IoC)是一种设计原则,它将对象的创建和管理权从代码中剥离出来,转交给一个外部容器(如Spring框架)。通过这种方式,开发者可以专注于业务逻辑,而不是对象的...
基于annotation注解方式理解SpringIOC控制反转
这将帮助初学者理解Spring IOC的工作原理,以及如何在实际项目中应用这些概念。 总的来说,这个压缩包提供了一个学习和实践Spring IOC的基础环境。通过研究和运行这些代码,开发者可以更好地理解依赖注入如何解耦...
**Spring控制反转(IoC)理解** Spring框架的核心特性之一是控制反转(Inversion of Control,简称IoC),也常被称为依赖注入(Dependency Injection,简称DI)。IoC是一种设计模式,它将对象的创建和管理从应用代码...
Spring IOC(Inversion of Control,控制反转)是Spring框架的核心特性,它改变了传统Java应用程序中对象的创建和管理方式。在传统的程序设计中,我们通常手动创建对象并管理它们之间的依赖关系,而在Spring中,这些...
在软件开发中,IoC(Inversion of Control,控制反转)是一种设计模式,它将对象的创建和管理责任从代码中剥离出来,交由一个容器来处理。Spring框架是Java平台上的一个核心组件,其核心特性就是依赖注入...
首先,理解控制反转(IoC)的概念至关重要。传统的编程方式中,对象创建和管理是由程序员直接控制的,而 IoC 将这种控制权反转,使得容器负责对象的创建、配置和管理。这样做的好处是降低了代码间的耦合性,提高了...
Spring框架的核心特性之一是控制反转(Inversion of Control,IoC),这与依赖注入(Dependency Injection,DI)密切相关。这两个概念都是为了实现软件组件之间的松耦合,从而提高系统的可扩展性和可维护性。 控制...
在Spring框架的项目中,我们需要在构建工具(如Maven或Gradle)的配置文件中声明对Spring Core和Spring Context等模块的依赖。例如,添加`<dependency>`标签引入`spring-context`模块,这是Spring框架实现IoC和DI的...
控制反转(Inversion of Control,简称IoC)是面向对象编程中的一种设计原则,它将对象的创建和管理责任从代码中剥离出来,交由一个外部容器(如Spring框架)来处理。这种模式使得程序的组件之间解耦,提高了代码的...
在Spring框架中,IOC(Inversion of Control,控制反转)是其核心概念之一,它改变了传统应用程序中的对象创建和管理方式。本学习资料主要聚焦于Spring的IOC容器,特别是从最基本的BeanFactory开始,逐步深入理解...
首先,让我们来理解控制反转(IoC)。在传统的编程模式中,对象通常会自行创建或管理它们依赖的其他对象。这种情况下,对象的控制权在于对象本身。而IoC则将这种控制权反转,由外部容器(在这种情况下是Spring容器)...
通过这些学习资料,开发者可以逐步掌握Spring框架的各个方面,从基本概念到高级特性和最佳实践,从而在实际项目中灵活运用Spring。此外,学习过程中还应关注Spring社区的最新动态,参与讨论,解决实际遇到的问题,...
Spring框架是Java开发中不可或缺的一部分,它以其IoC(控制反转)和AOP(面向切面编程)的核心特性,极大地简化了企业级应用的开发。本资料“Spring学习笔记&源码”是基于网易云课堂黑马程序员的Spring四天精通课程...
Spring 2.0是Java开发中的一个里程碑,它在企业级应用开发中扮演着至关重要的角色,特别是对于依赖注入(IoC)和面向切面编程(AOP)的支持。本学习提纲旨在为初学者提供一份详尽的Spring 2.0学习指南,帮助他们系统...
在深入了解Spring框架之前,我们首先需要理解“控制反转”(Inversion of Control,简称IoC)的概念。IoC是一种设计原则,旨在减少组件之间的耦合度,提高代码的可维护性和可测试性。在传统的编程模式中,组件或对象...
首先,理解控制反转(IOC)的概念至关重要。在传统的编程模式中,对象通常自行创建依赖对象,而在IOC中,这种创建和管理对象的责任被转移到了一个外部容器,即IOC容器。这样,对象只需要声明它们的依赖,而无需知道...
由于提供的文件内容中存在大量重复的网址信息,并没有实际的教学内容或者相关知识点,我将从标题...学习Spring也是一个不断实践和解决问题的过程,通常建议开发者在实际项目中边做边学,加深对知识的理解和应用。