spring核心：bean工厂的装配 5

本文中主要包含：

19.方法的注入

20.bean的生命周期接口

21.让bean知道自己的身份

22.父bean和子bean

19.方法的注入

方法的注入的引入主要是用来解决下面的问题：在spring中，一个singleton bean A，在每次方法调用中需要产生一个non-singleton的bean B，spring仅仅会一次创建A，并且设置这个bean的属性，所以无法为外界提供一个不同的B。为此spring中引入了‘方法注入’的概念。

MyLookupBean.java

package beanfactory.coredi;
/**
* @author jefferyxu
*
*/
public class MyLookupBean {

/**
* 这个方法将被spring重写
* @return
*/
protected AnotherBean newAnotherBean() {
return null;
}

public void doSomethingWithAnotherBean() {
AnotherBean anotherBean = new AnotherBean();

System.out.println(anotherBean.hashCode());
}
}

applicationContext.xml:

<!--
lookup方法能够重写bean的抽象方法或者是具体方法，返回的是
容器中的bean实例,这里解决的是singleton类的non-sinlgeton
属性
-->
<bean id="myBean" class="beanfactory.coredi.MyLookupBean"
abstract="false" lazy-init="default" autowire="default">
<lookup-method name="newAnotherBean" bean="anotherBean" />
</bean>

客户端程序：

MyLookupBean myBean1 = (MyLookupBean)context.getBean("myBean");
myBean1.doSomethingWithAnotherBean();

MyLookupBean myBean2 = (MyLookupBean)context.getBean("myBean");
myBean2.doSomethingWithAnotherBean();

20.bean的生命周期接口

spring中提供了一些bean声明周期的接口，其中包含了InitializingBean和DisposableBean。它们可以改变bean的行为。

1.InitializingBean源码如下：

public interface InitializingBean {

/**
* Invoked by a BeanFactory after it has set all bean properties supplied
* (and satisfied BeanFactoryAware and ApplicationContextAware).
* <p>This method allows the bean instance to perform initialization only
* possible when all bean properties have been set and to throw an
* exception in the event of misconfiguration.
* @throws Exception in the event of misconfiguration (such
* as failure to set an essential property) or if initialization fails.
*/
void afterPropertiesSet() throws Exception;
}

这个接口的使用方式如下：

AnotherBean.java:

package beanfactory.coredi;
public class AnotherBean {

/**
* bean的生命周期，一种简单的方法是实现spring的
* 接口，但是 一般不提倡这么做，因为这样的代码会和
* spring紧耦合
*/
public void initBean(){
System.out.println("init bean...");
}

public void destroyBean(){
System.out.println("destroy bean...");
}
}

applicationContext.xml:

<bean id="anotherBean" class="beanfactory.coredi.AnotherBean"
abstract="false" lazy-init="default" autowire="default" init-method="initBean"
destroy-method="destroyBean">
</bean>

2.DisposableBean

DisposableBean源码如下：

public interface DisposableBean {
/**
* Invoked by a BeanFactory on destruction of a singleton.
* @throws Exception in case of shutdown errors.
* Exceptions will get logged but not rethrown to allow
* other beans to release their resources too.
*/
void destroy() throws Exception;
}

使用方法和上面相似。

21.让bean知道自己的身份

1.BeanNameAware，spring通过该接口调用bean，此时该bean得到自身的一些信息，代码如下：

public interface BeanNameAware {
/**
* Set the name of the bean in the bean factory that created this bean.
* <p>Invoked after population of normal bean properties but before an
* init callback such as {@link InitializingBean#afterPropertiesSet()}
* or a custom init-method.
* @param name the name of the bean in the factory.
* Note that this name is the actual bean name used in the factory, which may
* differ from the originally specified name: in particular for inner bean
* names, the actual bean name might have been made unique through appending
* "#..." suffixes. Use the {@link BeanFactoryUtils#originalBeanName(String)}
* method to extract the original bean name (without suffix), if desired.
*/
void setBeanName(String name);
}

使用方法：

AwareBean.java:

/**
*
*/
package beanfactory.nature;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
/**
* @author jefferyxu
*
*/
public class AwareBean implements BeanNameAware, BeanFactoryAware {
private String beanName;
private BeanFactory beanFactory;

/* (non-Javadoc)
* @see org.springframework.beans.factory.BeanNameAware#setBeanName(java.lang.String)
*/
@Override
public void setBeanName(String name) {
// TODO Auto-generated method stub
this.beanName = name;
}
/* (non-Javadoc)
* @see org.springframework.beans.factory.BeanFactoryAware#setBeanFactory(org.springframework.beans.factory.BeanFactory)
*/
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
// TODO Auto-generated method stub
this.beanFactory = beanFactory;
}
public void init() {
System.out.println("bean factory: " +this.beanFactory +
" bean name : " + this.beanName);
}
}

applicationContext.xml:

<bean id="awareBean" class="beanfactory.nature.AwareBean"
abstract="false" lazy-init="default" autowire="default" init-method="init">
</bean>

2.BeanFactoryAware:

如果bean实现了上面的接口的话，那么当sping创建这个bean的时候，向这个bean中注入了产生这个bean的factory的引用。BeanFactoryAware代码：

public interface BeanFactoryAware {
/**
* Callback that supplies the owning factory to a bean instance.
* <p>Invoked after the population of normal bean properties
* but before an initialization callback such as
* {@link InitializingBean#afterPropertiesSet()} or a custom init-method.
* @param beanFactory owning BeanFactory (never <code>null</code>).
* The bean can immediately call methods on the factory.
* @throws BeansException in case of initialization errors
* @see BeanInitializationException
*/
void setBeanFactory(BeanFactory beanFactory) throws BeansException;
}

使用方法和上面的类似。

3.FactoryBean

FactoryBean它本身就是一个工厂，同时也是一个bean组件。有时候需要向spring中请求factory本身，而不是factory产生的类本身，那么这是在使用getBean时，需要在bean name前加上&符号，例如getBean("&BeanName").

22.父bean和子bean

一个bean的定义中可能包含了许多的定义，而一个bean的配置能够继承其父bean的属性，只需要设置与父bean不相同的属性。实例：

<!--
abstract="true"表明不能使用getBean得到对象的实例
-->
<bean id="parentBean" class="beanfactory.childbean.ParentBean"
abstract="true" p:name="parent">
<property name="age">
<value type="int">99</value>
</property>
</bean>

<!-- 这里只是重写了name属性，那么age属性就继承自parentBean -->
<bean id="childBean" class="beanfactory.childbean.ChildBean">
<property name="name" value="override"></property>
<property name="age" value="100"></property>
</bean>