Spring核心Bean工厂装配__Spring学习笔记

最新推荐文章于 2024-01-22 15:25:59 发布

Shine_Panda

最新推荐文章于 2024-01-22 15:25:59 发布

阅读量4.5k

点赞数

分类专栏： Spring 文章标签： spring bean string class setter 测试

本文链接：https://blog.csdn.net/caoyinghui1986/article/details/2488825

版权

Spring 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

在Spring 中最核心的组件是bean工厂，它提供了基本的反向控制和依赖注入的能力。Spring 是一种无侵入性的框架，被bean工厂管理的组件无须知道spring的存在。bean工厂负责打造bean，并注射它们之间的依赖。这些bean会彼此协作。 spring中最基本的BeanFactory接口org.springframework.beans.factory.BeanFactory ,它提供一些工厂的基本方法。

package org.springframework.beans.factory;

import org.springframework.beans.BeansFaException;

public interface BeanFacotory

{

//根据名字查找bean

Object getBean(String name) throws BeansException;

//检测目标bean是否具有指定的类型

Object getBean(String name,Class requiredType);

boolean containsBean(String name);

//检测某个bean 是否 singleton 如果是，则返回一个共享的实例。否则每次创建一个新的对象实例

boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

Class getType(String name) throws NoSuchBeanDefinitionException;

String getAliases(String name) throws NoSuchBeanDefinitionException;

}

实例化bean工厂的三种方法：

package com.cao.spring;

import org.springframework.beans.factory.BeanFactory;

import org.springframework.core.io.Resource;

import org.springframework.beans.factory.xml.XmlBeanFactory;

public class BeanFactoryUsage {

public static void main(String[] args){

//从文件系统资源实例化BeanFactory;

//默认从当前的工程目录下开始找。（工程目录/com/cao/文件目录）

org.springframework.core.io.Resource res = new org.springframework.core.io.FileSystemResource("com/cao/bean.xml");

org.springframework.beans.factory.BeanFactory factory = new org.springframework.beans.factory.xml.XmlBeanFactory(res);

System.out.println("OK"+factory);

//从classpath下的资源实例化BeanFactory (Eclipse 中的 src/data目录下)

org.springframework.core.io.Resource resClasspath = new org.springframework.core.io.ClassPathResource("data/bean2.xml");

org.springframework.beans.factory.BeanFactory factory2 = new XmlBeanFactory(resClasspath);

//使用ApplicationContext 从 classpath下的xml 文件实例化BeanFacotory

String classPath = "data/";

org.springframework.context.ApplicationContext appContext = new org.springframework.context.support.ClassPathXmlApplicationContext(new String[]{classPath+"bean2.xml"});

//直接生成类工厂的实例。

org.springframework.beans.factory.BeanFactory factory3 = (BeanFactory)appContext;

}

Bean工厂的处理过程
(1) Spring中，一个bean 定义被抽象为BeanDefinition接口每次实例化XMLBeanFactory 或ClassPathXmlApplicationContext时都会对xml 进行解析，形成AbstractBeanDefinition向BeanFactory进行注册。
(2) 在这个过程中有些BeanFactory还会进行预初始化 (如ClassPathXmlApplicatitonContxt). 这样客户代码在调用getBean的时候就可以迅速取得Bean的实例了。

使用静态工厂方法创建Bean

通过静态工厂方法创建Bean,使用factory-method属性来指定工厂方法名。目标bean的class属性正是哪个包含静态工厂的类。
<bean id="legacyBean" class="com.cao.LegacySingleton" factory-method="getInstance"/>
这个bean 配置并未指定返回对象的类型，只是指定包含工厂方法的类。并且该类的 getInstance 方法必须是静态方法。

使用实例工厂方法创建Bean

通过实例工厂方法创建Bean ，类似于使用静态工厂，它调用一个已知的bean的工厂方法来创建新的bean
<bean id="legacyBean" class="com.cao.ConcreteLegacyFactory" /> <bean id="product" factory-bean="legacyBean" factory-method="make"/>
classs 指定了具体的Bean工厂类型。 factory-bean 映射 id ="legacyBean" ; factory-method 指定了生产bean 的方法。

Spring中，Ioc/DI 主要有两种形式。
(1)基于设值方法的依赖注入,通过bean的setter方法实现。在构造方法或其他方法创建bean的实例后，进setter注入也是完全允许的。
(2)基于构造方法的依赖注入，通过调用带有多个参数的构造来实现的。这些参数代表bean的协作者(要注入的哪个实例)或属性。spring将通过特定参数的静态工厂方法来构造bean 也归到此类。

1，基于setter的依赖的bean 的配置

< bean id ="setterBean" class ="com.cao.SetterBean" >

< property name ="beanOne" >

< ref bean ="anotherBean" />

</ property >

< property name ="beanTwo" >

< ref bean ="yetAntherBean" />

</ property >

< property name ="integerProperty" >

< value > 1 < value >

</ property >

</ bean >

< bean id ="anotherBean" class ="com.cao.AnotherBean" />

< bean id ="yetAntherBean" class ="com.cao.YetAnotherBean" />

// 实现的类。

package com.cao.spring;

public class SetterBean {

private AnotherBean beanOne;

private YetAnotherBean beanTwo;

private int i;

public void setBeanOne(AnotherBean beanOne) {

this.beanOne = beanOne;

}

public void setIntegerProperty(int i) {

this.i = i;

}

public void setBeanTwo(YetAnotherBean beanTwo) {

this.beanTwo = beanTwo;

}

@Override

public String toString() {

// TODO Auto-generated method stub

return "beanOne"+this.beanOne+":beanTwo" +this.beanTwo+":int"+this.i;

}

public static void main(String[] args){

org.springframework.core.io.Resource rs = new org.springframework.core.io.ClassPathResource("data/setter.xml");

org.springframework.beans.factory.BeanFactory factory=

new org.springframework.beans.factory.xml.XmlBeanFactory(rs);

System.out.println(factory.getBean("setterBean"));

}

比较类和配置文件，可以看出。<property name="beanOne"> 的name对应类中的一个setXXX方法 xxx和name的值满足javaBean的定义。
<ref bean="anotherBean"/> bean 的值引用另一个bean的id <bean id="anotherBean" class="com.cao.AnotherBean" />

事实上就是将com.cao.AnotherBean这个类通过 setXXX方法设置到类com.cao.SetterBean中作为它的成员属性。

2，基于构造方法的DI配置

< beans >

< bean id ="constructBean" class ="com.cao.spring.ConstructBean" >

< constructor-arg >

< ref bean ="beanOne" />

</ constructor-arg >

< constructor-arg >

< ref bean ="beanTwo" />

</ constructor-arg >

< constructor-arg index ="2" >

< value type ="int" > 1 </ value >

</ constructor-arg >

</ bean >

< bean id ="beanOne" class ="com.cao.spring.AnotherBean" />

< bean id ="beanTwo" class ="com.cao.spring.YetAnotherBean" />

</ beans >

// 实现类

package com.cao.spring;

import org.springframework.beans.factory.BeanFactory;

import org.springframework.beans.factory.xml.XmlBeanFactory;

import org.springframework.core.io.ClassPathResource;

import org.springframework.core.io.Resource;

public class ConstructBean {

private AnotherBean beanOne;

private YetAnotherBean beanTwo;

private int i;

public ConstructBean(AnotherBean beanOne, YetAnotherBean beanTwo, int i) {

super();

this.beanOne = beanOne;

this.beanTwo = beanTwo;

this.i = i;

}

public String toString() {

// TODO Auto-generated method stub

return "beanOne"+this.beanOne+":beanTwo" +this.beanTwo+":int"+this.i;

}

public static void main(String[] args){

Resource rs = new ClassPathResource("data/construct.xml");

BeanFactory factory = new XmlBeanFactory(rs);

System.out.println(factory.getBean("constructBean"));

}

做了一个测试发现 <constructor-arg> 配置中的参数的顺序不一定与构造方法的参数的顺序相同。通过 index="2"来指定参数的位置(从0开始)

3,基于构造方法的DI配置__调用工厂方法(静态或非静态)

< beans >

< bean id ="diFactory" class ="com.cao.spring.DIFactory" />

< bean id ="product" factory-bean ="diFactory" factory-method ="make" >

< constructor-arg >

< ref bean ="beanOne" />

</ constructor-arg >

< constructor-arg >

< ref bean ="beanTwo" />

</ constructor-arg >

< constructor-arg >

< value > 1 </ value >

</ constructor-arg >

</ bean >

< bean id ="beanOne" class ="com.cao.spring.AnotherBean" />

< bean id ="beanTwo" class ="com.cao.spring.YetAnotherBean" />

< bean id ="productStatic" class ="com.cao.spring.DIFactory" factory-method ="create" >

< constructor-arg >

< ref bean ="beanOne" />

</ constructor-arg >

< constructor-arg >

< ref bean ="beanTwo" />

</ constructor-arg >

< constructor-arg >

< value > 1 </ value >

</ constructor-arg >

</ bean >

</ beans >

Spring自动装配(autowiring)
1, no 不进行自动装配，这是spring的默认配置。
2，byName 通过属性名进行自动装配。Spring 查找待装配的bean属性同名的bean。
(测试：发现当找不到匹配的时候取其默认值null / 0 引用类型为null ，基本数据类型为0 )
3，byType Spring 查找待装配的bean 同类型的bean，不过如果找到多于一个一上的bean 是会抛异常的。
(测试：哪怕是同一个bean对应不同的id也会报错,如果不足是不会报错只是为空。如果设置了 dependency-check="objects" 不足也会报错)
4，constructor 类似于 byType 。匹配构造子参数，而非属性。
5，autodetect 让spring 自动选择construtor 或 byType如果找到的是一个默认构造方法则使用byType

依赖检查：
模式：   说明
none     不进行依赖检查
simple   对基本类型和集合进行依赖检查
objects   对协作者(你所注入的哪个类)进行依赖检查
all      对协作者，基本类型和集合都进行检查

使用collection(集合) 元素定义集合。

< beans >

< bean id ="complext" class ="com.cao.spring.ComplexBean" >

< property name ="people" >

< props >

< prop key ="name" > Spirti.J </ prop >

< prop key ="age" > 25 </ prop >

</ props >

</ property >

< property name ="comeList" >

< list >

< value > list中的第一个元素,下一个元素是其他bean的引用 </ value >

< ref bean ="anotherBean" />

</ list >

</ property >

< property name ="someMap" >

< map >

< entry key ="key-String" value ="我是字符串甲" />

< entry >

< key >< value > key-String </ value ></ key >

< value > 我是字符串乙 </ value >

</ entry >

< entry key ="key-ref" value-ref ="anotherBean" ></ entry >

< entry >

< key >< value > key-ref </ value ></ key >

< ref bean ="anotherBean" />

</ entry >

</ map >

</ property >

< property name ="someSet" >

< set >

< value > 我是字符串丙 </ value >

< ref bean ="anotherBean" />

</ set >

</ property >

</ bean >

< bean id ="anotherBean" class ="com.cao.spring.AnotherBean" />

</ beans >

通过嵌套bean来定义内部bean
内部bean不需要任何id 或则 singleton 标记，它是一种匿名的内部原形，它的实例仅供外部类使用。

< bean id ="outerBean" class ="com.cao.spring.OuterBean" >

< property name ="target" >

< bean class ="com.cao.spring.ComplexBean" >

< property name ="people" >

< props >

< prop key ="name" > Spirit.J </ prop >

< prop key ="age" > 25 </ prop >

</ props >

</ property >

</ bean >

</ property >

</ bean >

方法注入
为什么需要方法注入？
假设一个singleton beanA 和一个non-singleton beanB 那么容器仅仅会对beanA实例化一次也就就只有一次机会去设置它的属性。所以无法每次为beanA
提供一个新的beanB的实例。因为beanB 是BeanA的属性。

使用lookup 方法注入，lookup 方法能够在运行时重写bean的抽象或具体方法，返回或创建容器中其他bean的实例。被创建的通常是一个non-singleton bean
但也可以是 singleton 的。(spring 通过CGLIB来实现这种注入)

< beans >

< bean id ="anotherBean" class ="com.cao.spring.AnotherBean" singleton ="false" />

< bean id ="myBean" class ="com.cao.spring.MyLookUpBean" >

< lookup-method name ="newAnotherBean" bean ="anotherBean" />

</ bean >

</ beans >

MyLookUpBean中有方法
protected AnotherBean newAnotherBean(){
return null;
}
在MyLookUpBean调用这个方法时候。spring 都会重写这个方法并返回一个 AnotherBean 的实例。

替换任意方法。
通过replace-method元素替换以存在的方法实现。
使用方法替换需要实现的接口 org.springfarmework.beans.factory.support.MethodReplacer接口。

< bean id ="myReplaceBean" class ="com.cao.spring.MyValueCalculator" >

< replaced-method name ="computeValue" replacer ="aaa" >

< arg-type > String </ arg-type >

</ replaced-method >

</ bean >

< bean id ="aaa" class ="com.cao.spring.ReplacementComputeValue" />

原本MyValueCalculator类中有一个方法。
public String computeValue(String input){
System.out.println("原始的计算");
return "";
}

结果在运行时被 ReplacementComputeValue 类中的实现所替换。改类实现了MethodReplacer接口。覆盖该接口中的 reimplement方法的实现作为
computeValue 实现的替换。<replaced-method>中的name 指定了要替换的方法。 replacer属性指定实现MethodReplacer接口的类。

Bean的原生属性
Spring 提供了一些生命周期的标记接口，包括InitializingBean 和DisposableBean. 他们可以改变bean的行为. 使得bean在初始化和析构时执行特定的处理
InitializingBean 中有 afterpropertiesSet() 方法一个bean 实现了InitializingBean接口后并实现这个方法可以用来完成初始化工作。但这样做有一个
弊端，就是 bean 与 spring 框架发生了耦合。更好的方法是通过在配置文件中用 init-method 属性来指定一个方法来完成初始化工作。
DisposableBean 和 destroy-method 属性的用法类似初始化。

Bean先完成属性的注入然后初始化当工厂销毁的时候。再销毁
在 singleton bean的情况下即使多次 factory.getBean("someBean"); 这些工作都只会执行一次包括属性的注入。

< bean id ="someBean" class ="com.cao.spring.SomeBean" init-method ="afterPropertiesSetOfMy" destroy-method ="destroyOfMy" >

获取Bean自身的相关信息
BeanNameAware 接口 Spring 容器通过该接口调用bean 获取相关信息。获取的时机是注入属性之后，初始化(init-method) 方法之前。

public class AwareBean implements org.springframework.beans.factory.BeanNameAware,org.springframework.beans.factory.BeanFactoryAware {

private String beanName;

private BeanFactory factory;

public void setBeanName(String arg0) {

this.beanName = arg0;

}

public void setBeanFactory(BeanFactory arg0) throws BeansException {

this.factory = arg0;

}

public void doInit(){

String name= factory.getClass().getName();

System.out.println("我是"+name+"创建的"+beanName);

}

public static void main(String[] args){

org.springframework.core.io.Resource rs =

new ClassPathResource("data/beanAware.xml");

org.springframework.beans.factory.BeanFactory factory =

new XmlBeanFactory(rs);

factory.getBean("beanAware");

}

分析代码我们可以发现一个Bean 竟然可以获得它的创建者(BeanFactory)的引用。那么我们就可以利用这个引用获得更多的信息。还可以将这个
BeanFactory 强制转型为合适的工厂类型从而获得更多的相关信息。

父子bean的定义
一个bean的定义可以包含大量的配置信息，而一个子bean的定义可以继承父bean的配置。并允许覆盖和添加一些其他信息。在Spring中可以把父bean看成是字bean
的模板。使用父子bean 可以减少很多重复的工作。子bean使用parent属性来指向父bean。

< bean id ="father" class ="com.cao.spring.ParentBean" >

< property name ="name" value ="parent" />

< property name ="age" value ="20" />

</ bean >

< bean id ="child" class ="com.cao.spring.ChildBean" parent ="father" >

< property name ="name" value ="override" />

</ bean >

1> ParentBean father = (ChildBean) factory.getBean("child");
2> ParentBean father = (ParentBean) factory.getBean("child");
father.getName();得到的都是 override说明 factory工厂创建的真正的实例还是ChildBean 当id = "Child" 的bean 没有class属性时可以用2>方法转型
得到的真正实例仍然是ChildBean

容器忽略既没有class也没有parent属性的bean

使用后理器(Post-Processor)
一个Bean post-processor 需要实现BeanPostProcessor接口。它有两个回调方法 postProcessBeforeInitialzation() 和 postProcessAfterInitialization();
如果一个 bean工厂注册了post-processor,那么对与所创建的每个bean实例。初始化方法前后都会得到一个回调。
测试发现: 使用BeanFactory 装配时候不需要在配置文件中映射你的后处理类。它会被自动调用。但要手动注册
        org.springframework.beans.factory.config.ConfigurableBeanFactory config= new XmlBeanFactor(rs);
         org.springframework.beans.factory.config.BeanPostProcessor postProcessor = new MyBeanPostProcessor();
   config.addBeanPostProcessor(postProcessor);

使用ApplicationContext 工厂自动装配时。要在配置文件映射该类。<bean id="postBean" class="com.cao.spring.MyBeanPostProcessor"/>
只要你的配置文件有 MyBeanPostProcessor 这个类。好象id是可以随便取的。

使用BeanFactoryPostProcessor
实现 BeanFacotoryPostProcessor的类就是一个Bean factory post-processor,它可以在bean 工厂创建后对整个bean 做某种修改。

PropertyPlaceholderConfigurer
它用来将Spring配置文件中的属性只抽离到一个单独的java Properties文件。
这样可以避免在Spring的配置进行修改。

完整的参考测试工程源码 Eclipse3.2+Tomcate5.0 http://download.csdn.net/source/470868

Shine_Panda

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
Spring核心Bean工厂装配__Spring学习笔记

在Spring 中最核心的组件是bean工厂，它提供了基本的反向控制和依赖注入的能力。Spring 是一种无侵入性的框架，被bean工厂管理的组件无须知道spring的存在。bean工厂负责打造bean，并注射它们之间的依赖。这些bean会彼此协作。 spring中最基本的BeanFactory接口org.springframework.beans.factory.BeanFactory ,它提供
复制链接

扫一扫