采用Spring管理Bean和依赖注入

1.实例化spring容器 和 从容器获取Bean对象

实例化Spring容器常用的两种方式：

方法一:

在类路径下寻找配置文件来实例化容器 [推荐使用]

ApplicationContext appContext = new ClassPathXmlApplicationContext("classpath*:/META-INF/spring/applicationContext-memcached.xml");

MemCachedManager cache = appContext.getBean(MemCachedManager.class);

方法二:

在文件系统路径下寻找配置文件来实例化容器 [这种方式可以在开发阶段使用]

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");

2.Spring实例化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(){   // 注意这里的这个方法是 static 的！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();}
}

.csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; }

3.Bean的生命周期 （Bean的作用域）

bean的scope 属性

The scope of this bean: typically "singleton" (one shared instance, which will be returned by all calls 
to getBean with the given id), or "prototype" (independent instance resulting from each call to 
getBean). Default is "singleton". Singletons are most commonly used, and are ideal for multi- 
threaded service objects. Further scopes, such as "request" or "session", might be supported by 
extended bean factories (e.g. in a web environment). Note: This attribute will not be inherited by 
child bean definitions. Hence, it needs to be specified per concrete bean definition. Inner bean 
definitions inherit the singleton status of their containing bean definition, unless explicitly specified: 
The inner bean will be a singleton if the containing bean is a singleton, and a prototype if the 
containing bean has any other scope.

.singleton  [单例] 
eg：<bean id="personService" class="com.yinger.service.impl.PersonServiceBean" scope="singleton"></bean>

在每个Spring IoC容器中一个bean定义只有一个对象实例。

请注意Spring的singleton bean概念与“四人帮”（GoF）模式一书中定义的Singleton模式是完全不同的。

经典的GoF Singleton模式中所谓的对象范围是指在每一个ClassLoader中指定class创建的实例有且仅有一个。

把Spring的singleton作用域描述成一个container对应一个bean实例最为贴切。亦即，假如在单个Spring容器内定义了某个指定class的bean，

那么Spring容器将会创建一个且仅有一个由该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“ ...>

.prototype [原型]

每次从容器获取bean都是新的对象。

对于prototype作用域的bean，有一点非常重要，那就是Spring不能对一个prototype bean的整个生命周期负责：容器在初始化、配置、装饰或者是

装配完一个prototype实例后，将它交给客户端，随后就对该prototype实例不闻不问了。不管何种作用域，容器都会调用所有对象的初始化生命周期回调方法。

但对prototype而言，任何配置好的析构生命周期回调方法都将不会被调用。清除prototype作用域的对象并释放任何prototype bean所持有的昂贵资源，

都是客户端代码的职责。（让Spring容器释放被prototype作用域bean占用资源的一种可行方式是，通过使用bean的后置处理器，该处理器持有要被清除的bean的引用。）

以下的三种scope只是在web应用中才可以使用

.request

.session

.global session

使用这三种配置之前要先初始化Web配置

5.xml配置方法和参数

<context:component-scan base-package="com.ibs.gbplarform.common.memcached" />

<bean id="memCachedPool" class="com.whalin.memcached.SockIOPool"

factory-method="getInstance" init-method="initialize" destroy-method="shutDown">

<constructor-arg>

<value>memCachedPool</value>

</constructor-arg>

<property name="servers">

<list>

<value>127.0.0.1:11211</value>

</list>

</property>

<property name="initConn">

<value>20</value>

</property>

<property name="minConn">

<value>10</value>

</property>

<property name="maxConn">

<value>50</value>

</property>

<property name="maintSleep">

<value>3000</value>

</property>

<property name="nagle">

<value>false</value>

</property>

<property name="socketTO">

<value>3000</value>

</property>

</bean>

<bean id="memCachedClient" class="com.whalin.memcached.MemCachedClient">

<constructor-arg>

<value>memCachedPool</value>

</constructor-arg>

</bean>