Spring（2）——Bean

2017-03-13 本文已影响32人拾壹北

// Bean例子
public class HelloBean {

    private static final Logger LOG = LoggerFactory
            .getLogger(HelloBean.class);

    private String name;

    private Integer age;
    protected String beanName;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        LOG.info("== 注入Bean属性 [{}] ==", name);
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public HelloBean() {
        LOG.info("== 构造方法 [{}] ==", beanName);
    }

    public HelloBean(String name) {
        this();
        this.name = name;
    }

}

1、XML配置Bean

<beans>

spring配置文件的根元素，包含一个或多个bean元素。

<bean>

属性

default-dependency-check：默认的依赖检查模式。可选四种。

none ：不进行依赖检查。没有指定值的bean属性仅仅是没有设值。
simple：对基本类型和集合（除了合作者外，比如其他的bean，所有东西）进行依赖检查。
object：对合作者进行依赖检查。
all ：对合作者，基本类型和集合都进行依赖检查。

default-lazy-init：默认延迟加载。True 或False 。

class：Java Bean 类名。

id：Java Bean在BeanFactory中的唯一标识，代码中通过BeanFactory获取JavaBean实例时需以此作为索引名称。

name：同上，如果给bean增加别名，可以通过name属性指定一个或多个id。

singleton：指定此Java Bean是否采用单例（Singleton）模式，如果设为“true”，则在BeanFactory作用范围内，只维护此Java Bean的一个实例，代码通过BeanFactory获得此Java Bean实例的引用。反之，如果设为“false”，则通过BeanFactory获取此Java Bean实例时，BeanFactory每次都将创建一个新的实例返回。

abstract：设定ApplicationContext是否对bean进行预先的初始化。

parent：定义一个模板。

autowire：bean自动装配模式。可选5种模式。

no：不使用自动装配。Bean的引用必须通过ref元素定义。
byName：通过属性名字进行自动装配。
byType：如果BeanFactory中正好有一个同属性类型一样的bean，就自动装配这个属性。如果有多于一个这样的bean，就抛出一个致命异常，它指出你可能不能对那个bean使用byType的自动装配。如果没有匹配的bean，则什么都不会发生，属性不会被设置。如果这是你不想要的情况（什么都不发生），通过设置dependency-check="objects"属性值来指定在这种情况下应该抛出错误。
constructor：这个同byType类似，不过是应用于构造函数的参数。如果在BeanFactory中不是恰好有一个bean与构造函数参数相同类型，则一个致命的错误会产生。
autodetect：通过对bean 检查类的内部来选择constructor或byType。如果找到一个缺省的构造函数，那么就会应用byType。

init-method：初始化方法，此方法将在BeanFactory创建JavaBean实例之后，在向应用层返回引用之前执行。一般用于一些资源的初始化工作。

destroy-method：销毁方法。此方法将在BeanFactory销毁的时候执行，一般用于资源释放。

factory-bean：通过实例工厂方法创建bean，class属性必须为空，factory-bean属性必

须指定一个bean的名字，这个bean一定要在当前的bean工厂或者父bean工厂中，并包含工厂方法。而工厂方法本身通过factory-method属性设置。

factory-method：设定工厂类的工厂方法。

depends-on：Bean依赖关系。一般情况下无需设定。Spring会根据情况组织各个依赖关系的构建工作。只有某些特殊情况下，如JavaBean中的某些静态变量需要进行初始化（这是一种BadSmell，应该在设计上应该避免）。通过depends-on指定其依赖关系可保证在此Bean加载之前，首先对depends-on所指定的资源进行加载。

子标签

**<property> **
用于设置一个属性。
name属性：属性的名称。
value属性：指定bean的属性值。BeanFactory将自动根据Java Bean对应的属性类型加以匹配。如果需要将属性值设定为null，必须使用<null/>节点。
ref属性：指定了属性对BeanFactory中其他Bean的引用关系。

**<value> **
指定bean的属性值。

**<ref> **
指定了属性对BeanFactory中其他Bean的引用关系。
bean属性：指定了属性对BeanFactory中其他Bean的引用关系。
local属性：指定了属性对BeanFactory中其他Bean的引用关系。（仅在本地（同一个）xml文件里寻找bean。
parent属性：指定了属性对BeanFactory中其他Bean模板的引用关系。

**<list> **
指定bean的属性类型为List的属性值。

**<map> **
指定bean的属性类型为List的属性值。

**<set> **
指定bean的属性类型为List的属性值。

**<props> **
指定bean的属性类型为Properties的属性值。

**<prop> **
key属性：指定Properties的键

**<idref> **
用来设置属性值为容器中其他bean的id 或name。

**<null> **
指定一个空值。

**<constructor-arg> **
使用构造方法注入，指定构造方法的参数。
index属性：设置参数的序号。
ref属性：同ref
type属性：参数类型。
value属性：参数的值。

**<lookup-method> **
lookup方法注入
bean属性：要注入的bean名
name属性：要注入的方法名称

**<replaced-method> **
用来把已存在的方法实现替换为其他的实现。
name属性：要替换的方法名
replacer属性：替换者类，实现org.springframework.beans.factory.support.MethodReplacer
接口）

**<arg-type> **
方法返回的类型

util命名空间配置

集合：

<util:list> </util:list>
<util:map> </util:map>
<util:set> </util:set>

<util:list id="placeHolderList">
    <value>test</value>
</util:list>

properties属性文件
util:properties：可以通过location属性指定其properties属性文件的位置

<util:properties> </util:properties>
<util:properties id="settings" location="classpath:config/placeholder.properties"/>

例子：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd"
       default-lazy-init="true">

    <bean name="helloBean" class="com.stepbystep.spring4.samples.beans.HelloBean"
          init-method="initMethod" destroy-method="destroyMethod">
        <property name="name" value="Spring"></property>
        <property name="age" value="0"></property>
    </bean>

    <bean name="helloBean2" class="com.stepbystep.spring4.samples.beans.HelloBean"
          p:name="test" p:age="2"/>
    <bean name="helloBean3" class="com.stepbystep.spring4.samples.beans.HelloBean" p:age="3"/>

    <bean name="helloBean4" class="com.stepbystep.spring4.samples.beans.HelloBean" p:name="${name}" p:age="4"/>

    <!--<bean class="com.stepbystep.spring4.samples.beans.lifecycle.BeanFactoryPostProcessorAdapter"></bean>-->
    <!--<bean class="com.stepbystep.spring4.samples.beans.lifecycle.BeanPostProcessorAdapter"></bean>-->

    <util:list id="list">
        <value>java</value>
        <value>bean</value>
    </util:list>

    <util:map id="map" map-class="java.util.HashMap" >
         <entry key="key1" value-ref="some1"/>
         <entry key="key2" value-ref="some2"/>
         <entry key="key3" value-ref="some3"/>
    </util:map>

    <bean id="someBean" class="cn.itcast.spring._util.SomeBean">
         <property name="someStrArray" ref="strArray"/>
         <property name="someObjArray" ref="objArray"/>
         <property name="someList" ref="list"/>
         <property name="someMap" ref="map"/>
    </bean>
    
</beans>

2、Groovy配置Bean

例子：

import com.stepbystep.spring4.samples.beans.HelloBean

beans{
    helloBean(HelloBean){
        name='GroovyBean'
        age=8
    }
}

3、Bean的实例化方法

步骤：

（1）实例化一个BeanFactory（可以根据具体需要从BeanFactory的多个实现类中实例化一个）；

    BeanFactory beanFactory0 = new DefaultListableBeanFactory();
    BeanFactory beanFactory1 = new ClassPathXmlApplicationContext();
    BeanFactory beanFactory2 = new FileSystemXmlApplicationContext();
    BeanFactory beanFactory3 = new GenericApplicationContext();
    BeanFactory beanFactory4 = new GenericGroovyApplicationContext();
    BeanFactory beanFactory5 = new GenericXmlApplicationContext();
    BeanFactory beanFactory6 = new StaticApplicationContext();
    BeanFactory beanFactory7 = new StaticListableBeanFactory();
    BeanFactory beanFactory8 = new AnnotationConfigApplicationContext();

（2）实例化一个BeanDefinitionReader：
有两个实现类：XmlBeanDefinitionReader（读取xml中的bean）GroovyBeanDefinitionReader（读取groovy中的bean）；实例化时将BeanFactory作为参数传入：

XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader((BeanDefinitionRegistry) beanFactory);
GroovyBeanDefinitionReader beanDefinitionReader = new GroovyBeanDefinitionReader(beanFactory);

（3）实例化Resource：
同样有多个实现类，用于不同的资源文件：

Resource resource0 = new ClassPathResource();
Resource resource1 = new ByteArrayResource();
Resource resource2 = new DescriptiveResource();
Resource resource3 = new FileSystemResource();
Resource resource4 = new InputStreamResource();
Resource resource5 = new PathResource();
Resource resource6 = new UrlResource();
Resource resource7 = new VfsResource();

（4）load资源文件：

beanDefinitionReader.loadBeanDefinitions(resource);

（5）最后就是通过BeanFactory对bean配置文件中的bean进行各种花式操作了，包括获取一个bean实例、读取properties属性文件等。

例子：

从xml文件读取bean：

@Test
public void testBeanFactoryXml(){
    BeanFactory beanFactory = new DefaultListableBeanFactory();

    XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader((BeanDefinitionRegistry) beanFactory);
    ClassPathResource resource = new ClassPathResource("spring/hello-bean.xml");
    beanDefinitionReader.loadBeanDefinitions(resource);

    HelloBean bean = beanFactory.getBean("helloBean",HelloBean.class);
    bean.sayHello();

    printBeans((ListableBeanFactory) beanFactory);
}

private void printBeans(ListableBeanFactory beanFactory) {
    StringBuilder sb =new StringBuilder("\n");
    for (String s : beanFactory.getBeanDefinitionNames()) {
        sb.append(s).append("\n");
    }
    LOG.info("beanNames = {}",sb.toString());
    LOG.info("beanNames.size = {}",beanFactory.getBeanDefinitionCount());
}

从Groovy文件读bean：

@Test
public void testBeanFactoryGroovy(){
    DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
    GroovyBeanDefinitionReader beanDefinitionReader = new GroovyBeanDefinitionReader(beanFactory);
    ClassPathResource resource = new ClassPathResource("spring/helloBean.groovy");
    beanDefinitionReader.loadBeanDefinitions(resource);

    HelloBean bean = beanFactory.getBean(HelloBean.class);
    org.junit.Assert.assertNotNull(bean);
    bean.sayHello();
    LOG.info("beanFactory = {}",beanFactory );
}

4、Bean的生命周期

Spring Bean的完整生命周期从创建Spring容器开始，直到最终Spring容器销毁Bean，这其中包含了一系列关键点：

完整的bean生命周期

监视Bean的生命周期

为BeanFactory添加BeanPostProcessor

自定义BeanPostProcessor，实现相应的接口和接口方法：
```
public class BeanPostProcessorAdapter implements BeanPostProcessor,
InstantiationAwareBeanPostProcessor,DestructionAwareBeanPostProcessor { ... }
```
BeanPostProcessor：
初始化前处理：Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
初始化后处理：Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;

InstantiationAwareBeanPostProcessor：
实例化前处理：Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException;
实例化后处理：boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException;
实例化处理属性：PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException;

DestructionAwareBeanPostProcessor：
销毁前处理： void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException;
boolean requiresDestruction(Object bean);

Bean实现对应的接口可以在其生命周期的特定时间回调相应的接口方法：

InitializingBean
void afterPropertiesSet() throws Exception; // 初始化接口回调
DisposableBean
void destroy() throws Exception; // 销毁接口回调
BeanNameAware
void setBeanName(String name); // 执行Aware操作，让Bean获取自己在BeanFactory配置中的名字（根据情况是id或者name）