7 -- Spring的基本用法 -- 8...

　　　　7.8 深入理解容器中的Bean

　　　　　　7.8.1 抽象Bean与子Bean

　　　　　　　　把多个<bean.../>配置中相同的信息提取出来，集中成配置模版------这个配置模版并不是真正的Bean，因此Spring不应该创建该配置模版，于是需要为该<bean.../>配置增加abstract=“true” ------这就是抽象Bean。

　　　　　　　　抽象Bean不能被实例化，Spring容器不会创建抽象Bean实例。抽象Bean的价值在于被继承，抽象Bean通常作为父Bean被继承。

　　　　　　　　抽象Bean只是配置信息的模版，指定abstract=“true”即可阻止Spring实例化该Bean，因此抽象Bean可以不指定class属性。

　　　　　　　　将大部分相同信息配置成抽象Bean之后，就实际Bean实例配置成该抽象Bean的子Bean即可。子Bean定义可以从父Bean继承实现类、构造器参数、属性值等配置信息，除此之外，子Bean配置可以增加新的配置信息，并可指定新的配置信息覆盖父Bean的定义。

　　　　　　　　通过为一个<bean.../>元素指定parent属性即可指定该Bean是一个子Bean，parent属性指定该Bean所继承的父Bean的id。

　　　　　　　　子Bean无法从父Bean继承如下属性：depends-on、autowire、singleton、scope、lazy-init，这些属性将总是从子Bean定义中获得，或采用默认值。

　　　　　　　　Interface ： Axe

package edu.pri.lime._7_8_1.bean;

public interface Axe {
    public String chop();
}

　　　　　　　　Class ： SteelAxe

package edu.pri.lime._7_8_1.bean.impl;

import edu.pri.lime._7_8_1.bean.Axe;

public class SteelAxe implements Axe{

    public String chop() {
        return "用钢斧砍柴真快";
    }

}

　　　　　　　　Interface ： Person

package edu.pri.lime._7_8_1.bean;

public interface Person {
    public void useAxe();
}

　　　　　　　　Class ： Chinese

package edu.pri.lime._7_8_1.bean.impl;

import edu.pri.lime._7_8_1.bean.Axe;
import edu.pri.lime._7_8_1.bean.Person;

public class Chinese implements Person{

    private String name;
    private Axe axe;
    public void useAxe() {
        System.out.println(name + " 说：" + axe.chop());
    }
    public Axe getAxe() {
        return axe;
    }
    public void setAxe(Axe axe) {
        this.axe = axe;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

}

　　　　　　　　Class ： American

package edu.pri.lime._7_8_1.bean.impl;

import edu.pri.lime._7_8_1.bean.Axe;
import edu.pri.lime._7_8_1.bean.Person;

public class American implements Person{

    private String name;
    private Axe axe;
    public void useAxe() {
        System.out.println(name + " say: " + axe.chop());
    }
    public Axe getAxe() {
        return axe;
    }
    public void setAxe(Axe axe) {
        this.axe = axe;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

}

　　　　　　　　XML ：

<?xml version="1.0" encoding="UTF-8"?>
<!-- Spring 配置文件的根元素，使用Spring-beans-4.0.xsd语义约束 -->
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://www.springframework.org/schema/beans"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">
    <!-- 定义Axe实例 -->
    <bean id="steelAxe" class="edu.pri.lime._7_8_1.bean.impl.SteelAxe" />
    <!-- 指定abstract=“true”定义抽象Bean -->
    <!-- 如果父Bean指定了class 属性，那么子Bean连class属性都可以省略，子Bean将采用与父Bean相同的实现类 -->
    <bean id="personTemplate" abstract="true">
        <property name="name" value="lime" />
        <property name="axe" ref="steelAxe" />
    </bean>
    <!-- 通过指定parent属性指定Bean配置可从父Bean继承得到配置信息 -->
    <bean id="chinese" class="edu.pri.lime._7_8_1.bean.impl.Chinese"
        parent="personTemplate" />
    <bean id="american" class="edu.pri.lime._7_8_1.bean.impl.American"
        parent="personTemplate">
        <property name="name" value="oracle" />
    </bean>
</beans>

　　　　　　　　Class ： SpringTest

package edu.pri.lime._7_8_1.main;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import edu.pri.lime._7_8_1.bean.Person;
import edu.pri.lime._7_8_1.bean.impl.American;
import edu.pri.lime._7_8_1.bean.impl.Chinese;

public class SpringTest {

    public static void main(String[] args){
        ApplicationContext ctx = new ClassPathXmlApplicationContext("app_7_8_1.xml");
        Person chinese = (Person) ctx.getBean("chinese",Chinese.class);
        Person american = (Person) ctx.getBean("american",American.class);
        chinese.useAxe();
        american.useAxe();
    }
}

　　　　　　　　Console ：

lime 说：用钢斧砍柴真快
oracle say: 用钢斧砍柴真快

　　　　　　7.8.2 Bean继承与Java继承的区别

　　　　　　　　Spring中的Bean继承与Java中的继承中，Spring中的Bean继承是实例与实例之间参数值的延续，Java中的继承是一般到特殊的细化；Spring中的Bean继承是对象与对象之间的关系，Java中的继承是类与类之间的关系。

　　　　　　　　区别：

　　　　　　　　　　⊙ Spring中的子Bean和父Bean可以是不同类型，但Java中的继承则可保证子类是一种特殊的父类。

　　　　　　　　　　⊙ Spring中Bean的继承是实例之间的关系，因此主要表现为参数值的延续；而Java中的继承是类之间的关系，主要表现为方法、属性的延续。

　　　　　　　　　　⊙ Spring中的子Bean不可作为父Bean使用，不具备多态性；java中的子类实例完全可当成父类实例使用。

　　　　　　　　说到底，Spring中的Bean继承与Java中的继承其实就是两码事。表混淆就行了。

　　　　　　7.8.3 容器中的工厂Bean

　　　　　　　　Spring容器中的工厂Bean是一种特殊的Bean，必须实现FactoryBean接口。

　　　　　　　　FactoryBean接口是工厂Bean的标准接口，把工厂Bean(实现FactoryBean接口的Bean)部署在容器中之后，如果程序通过getBean()方法来获取它时，容器返回的不是FactoryBean实现类的实例，而是返回FactoryBean的产品(即该工厂Bean的getObject()方法的返回值).

　　　　　　　　FactoryBean接口中的方法：

　　　　　　　　　　⊙ T getObject() ： 实现该方法负责返回该工厂Bean生成的Java实例。

　　　　　　　　　　⊙ Class<?> getObjectType() ： 实现该方法返回该工厂Bean生成的Java实例的实现类。

　　　　　　　　　　⊙ boolean isSingleton() ： 实现该方法表示该工厂Bean生成的Java实例是否为单例模式。

　　　　　　　　程序把获取指定类的、指定类变量的实现逻辑放在getObject()方法中即可。

　　　　　　　　Class ： GetFieldFactoryBean

package edu.pri.lime._7_8_3.bean.impl;

import java.lang.reflect.Field;

import org.springframework.beans.factory.FactoryBean;

public class GetFieldFactoryBean implements FactoryBean<Object>{

    private String targetClass;
    private String targetField;

//    负责返回工厂Bean生成的Java实例
    public Object getObject() throws Exception {
//        froName(String) : 返回与带有给定字符串名的类或接口相关联的 Class 对象。
        Class<?> clazz = Class.forName(targetClass);
//        getField(String) : 返回一个指定名称的公共属性
        Field field = clazz.getField(targetField);
//        get(Object) ： 返回指定对象上此Field表示的字段的值
//        为什么get(null)：静态属性直接通过.get(null)获取
        Object obj = field.get(null);
        return obj;
    }
    public Class<? extends Object> getObjectType() {
//        哪里来的Object？
        return Object.class;
    }
//    返回该工厂Bean所生产的产品是否为单例
    public boolean isSingleton() {
//        非单例Bean
        return false;
    }
    public String getTargetClass() {
        return targetClass;
    }
    public void setTargetClass(String targetClass) {
        this.targetClass = targetClass;
    }
    public String getTargetField() {
        return targetField;
    }
    public void setTargetField(String targetField) {
        this.targetField = targetField;
    }
}

　　　　　　　　XML ：

<?xml version="1.0" encoding="UTF-8"?>
<!-- Spring 配置文件的根元素，使用Spring-beans-4.0.xsd语义约束 -->
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://www.springframework.org/schema/beans"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">
    <!--
    下面配置相当于如下代码：
    FactoryBean factory = new edu.pri.lime._7_8_3.bean.impl.GetFieldFactoryBean（）；
    factory.setTargetClass("java.awt.borderLayout"); facotry.setTargetField("NORTH");
    north = factory.getObject();
     -->
    <bean id="north" class="edu.pri.lime._7_8_3.bean.impl.GetFieldFactoryBean">
        <property name="targetClass" value="java.awt.BorderLayout"/>
        <property name="targetField" value="NORTH"/>
    </bean>
    <bean id="theValue" class="edu.pri.lime._7_8_3.bean.impl.GetFieldFactoryBean">
        <property name="targetClass" value="java.sql.ResultSet"/>
        <property name="targetField" value="TYPE_SCROLL_SENSITIVE"/>
    </bean>
</beans>

　　　　　　　　Class ： SpringTest

package edu.pri.lime._7_8_3.main;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {

    public static void main(String[] args){
        ApplicationContext ctx = new ClassPathXmlApplicationContext("app_7_8_3.xml");
//        获取FactoryBean的产品
        System.out.println(ctx.getBean("north"));
        System.out.println(ctx.getBean("theValue"));
//        获取FactoryBean本身
//        在Bean id前增加&符号，会让Spring返回FactoryBean本身
        System.out.println(ctx.getBean("&theValue"));
    }
}

　　　　　　　　Spring容器会自动检测容器中的所有Bean，如果发现某个Bean实现类实现了FactroyBean接口，Spring容器就会在实例化该Bean、根据<property.../>执行setter方法之后，额外调用该Bean的getObject()方法，并将该方法的返回值作为容器中的Bean。

　　　　　　　　Spring框架提供的FieldRetrievingFactoryBean，实现原理与GetFieldFactoryBean的原理基本相同。

　　　　　　7.8.4 获得Bean本身的id

　　　　　　　　对于实际的Java应用而言，Bean与Bean之间的关系是通过依赖注入管理的，通常不会通过调用容器的getBean()方法来获取Bean实例。可能的情况是，应用中已经获得了Bean实例的引用，但程序无法知道配置该Bean时指定的id，可是程序又确实需要获取配置该Bean时指定的id属性。

　　　　　　　　除此之外，当程序员在开发一个Bean类时，该Bean何时被部署到Spring容器中，部署到Spring容器时所指定的id是什么，开发该Bean类的程序员无法提前预知。

　　　　　　　　在某些极端情况下，业务要求程序员在开发Bean类时能预先知道该Bean的配置id，此时可借助Spring提供的BeanNameAware接口，通过该接口即可提前预知该Bean的配置id。

　　　　　　　　BeanNameAware接口提供了一个方法：setBeanName(String name)，该方法的name参数就是Bean的id，实现该方法的Bean类就可以通过该方法来获取部署该Bean的id了。

　　　　　　　　Class ： Chinese

package edu.pri.lime._7_8_4.bean;

import org.springframework.beans.factory.BeanNameAware;

//Spring容器会检测容器中的所有Bean，如果发现某个Bean实现了BeanNameAware接口，
//Spring容器就会在创建该Bean之后，自动调用该Bean的setBeanName()方法，
//调用该方法时，会将该Bean的配置id作为参数传给该方法------
//该方法的实现部分将SPring容器的参数（Bean的配置id）赋给该Chinese对象的name实例变量，
//之后可通过该name实例变量来访问容器本身
public class Chinese implements BeanNameAware {

    private String name;

    public void setBeanName(String name) {
        this.name = name;
    }

    public void info() {
        System.out.println("Chinese实现类" + "，部署该Ben时指定的id为：" + name);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

　　　　　　　　XML ：

<?xml version="1.0" encoding="UTF-8"?>
<!-- Spring 配置文件的根元素，使用Spring-beans-4.0.xsd语义约束 -->
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://www.springframework.org/schema/beans"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">

    <bean id="chinese" class="edu.pri.lime._7_8_4.bean.Chinese" />

</beans>

　　　　　　　　Class ： SpringTest

package edu.pri.lime._7_8_4.main;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import edu.pri.lime._7_8_4.bean.Chinese;

//Spring容器初始化Chinese Bean时回调setBeanName()方法，回调该方法时，
//该Bean的配置id将会作为参数传给beanName实例变量。
public class SpringTest {
    public static void main(String[] args){
        ApplicationContext ctx = new ClassPathXmlApplicationContext("app_7_8_4.xml");
        Chinese chinese = ctx.getBean("chinese",Chinese.class);
        chinese.info();
    }

}

　　　　　　7.8.5 强制初始化Bean

　　　　　　　　在大多数情况下，Bean之间的依赖非常直接，Spring容器在放回Bean实例之前，先要完成Bean依赖关系的注入。

　　　　　　　　在极端情况下，Bean之间的依赖不够直接。比如：某个类的初始化块中使用其他Bean，当初始化块时，被依赖Bean可能还没有被实例化，此时将会引发异常。

　　　　　　　　为了显示指定被依赖Bean在目标Bean之前初始化，可以使用depends-on属性，该属性可以在初始化主调Bean之前，强制初始化一个或多个Bean。

    <bean id="chinese" class="edu.pri.lime._7_8_4.bean.Chinese" depends-on="steelAxe"/>
    <bean id="steelAxe" class="edu.pri.lime._7_8_5.bean.SteelAxe"/>

啦啦啦