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"/>
啦啦啦