spring学习笔记2——基本Bean配置

最新推荐文章于 2025-03-26 22:02:13 发布

cdsnmdl

最新推荐文章于 2025-03-26 22:02:13 发布

阅读量1.9k

点赞数

CC 4.0 BY-SA版权

分类专栏： Spring学习笔记文章标签： bean spring class constructor prototype crash

本文链接：https://blog.youkuaiyun.com/cdsnmdl/article/details/4405133

Spring学习笔记专栏收录该内容

5 篇文章

订阅专栏

本文深入介绍了Spring框架中Bean的管理机制，包括BeanFactory和ApplicationContext的功能区别，Bean的创建、注入及装配过程，以及Bean的范围化、初始化和销毁等关键知识点。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

BeanFactory介绍

正如其名字所暗示的，Bean工厂采用了工厂设计模式。就是说，这个类负责创建和分发Bean。在Spring中有几种BeanFactory的实现。其中最常用的是org.springframework.beans.factory.xml.XmlBeanFactory，她根据XML文件中的定义装在Bean。

要创建XmlBeanFactory，学要传递一个org.springframework.core.io.Resource实例给构造函数。此Resource对象提供XML文件工厂。Spring提供了有应的Resource实现。如下表所示：

Resource实现	目的
org.springframework.core.io.ByteArrayResource	定义内容由一组字节给定的资源
org.springframework.core.io.ClassPathResource	定义可从classpath提取的资源
org.springframework.core.io.DescruptiveResource	定义包含资源描述符但是实际没有可读资源的资源
org.springframework.core.io.FileSystemResource	定义可从文件系统提取的资源
org.springframework.core.io.InputStreamResource	定义可从输入流提取的资源
org.springframework.web.portlet.context.PortletContextResource	定义可用在portlet上下文中的资源
org.springframework.web.context.support.ServletContextResource	定义可用在servlet上下文中的资源
org.springframework.core.io.UrlResource	定义可从给定URL提取的资源

例如下面的代码使用一个FileSystemResource来创建一个XmlBeanFactouy,其中Bean的定义来自文件系统中的XML文件：

BeanFactory factory = new XmlBeanFactory(new FileSystemResource("c:/beans.xml"));
MyBean myBean = (MyBean)factory.getBean("myBean");

使用应用上下文：

BeanFactory对简单的应用来说已经很好了，但是为了获得Spring框架的强大功能，你需要使用Spring的更加高级的容器——应用上下文。

表面上ApplicationContext和BeanFactory差不多。两者都是载入Bean定义信息，装配Bean，根据需要分发Bean。但是ApplicationContext提供了更多功能：

文本信息解析工具，包括对国际化（I18N）的支持。
提供了载入文件资源的通用方法，如载入图片。
可以向注册为监听去的Bean发送事件。

在ApplicationContext的诸多实现中欧冠，有三个实现经常用到：

ClassPathXmlApplicationcContext——从类路径中的XML文件载入上下文定义信息，把上下文定义文件当成类路径资源。
FileSystemXmlApplicationContext——从文件系统中的XML文件载入上下文定义信息。
XmlWebApplicationContext——从Web系统中的XML文件载入下上文定义信息。

基于Web的Spring中要介绍XmlWebApplicationContext，这里简单的介绍ClassPathXmlApplicationcContext和FileSystemXmlApplicationContext，如下面代码所示：

ApplicationContext ctx = new FileSystemXmlApplicationContext("foo.xml");
ApplicationContext ctx = new ClassPathXmlApplicationContext("foo.xml");

它俩的区别是FileSystemXmlApplicationContext只能从指定的路径中寻找foo.xml文件，而ClassPathXmlApplicationContext可以在整个类路径（包括jar文件）中寻找foo,xml文件。无论哪种实现使用getBean()方法获取Bean。

创建Bean

生命一个接口：

public interface Performer {
void perform() throws PerformanceException;
}

创建一个简单的Bean

package com.springinaction.springidol;

public class Juggler implements Performer {
   private int beanBags = 3;

   public Juggler() {}

   public juggler(int beanBags) {
   this.beanBags = beanBags;
   }

   public void perform() throws PerformanceException {
   System.out.println("JUGGLING" + beanBags + "BEANBAGS"):
   }
}

下面是在Spring配置文件中如何配置的：

通过构造函数注入：

注入Bean属性

public interface Instrument {
   void play();
}
public class Saxophone implements Instrument {
   public Saxophone() {}

   public void play() {
   System.out.println("TOOT TOOT TOOT");
   }
}
publci class Instrumentalist implement Performer {
   public Instrumentalist() {}

   public void perform() throws PerformanceException {
   System.out.print("Playing" + song + ":");
   instrument.play();
   }

   private int age;
   public void setSong(int age) {
   this.age= age;
   }

   private String song;
   public void setSong(String song) {
   this.song = song;
   }

   private Instrument instrument;
   public void setInstrument (Instrument instrument) {
   this.instrument= instrument;
   }
}

装配集合：

package org.spring.beans.collection;

import java.util.Collection;

import java.util.Iterator;

import java.util.Map;

import java.util.Properties;

public class OneManBand implements Performer {

public OneManBand(){}

public void perform() {

System.out.println("---------------List--------------------");

for(Instrument instrument : instruments){

instrument.play();

}

System.out.println("---------------Set--------------------");

for(Instrument instrument : instruments2){

instrument.play();

}

System.out.println("---------------Map--------------------");

for(String key : instruments3.keySet()){

System.out.print(key+" : ");

Instrument instrument = instruments3.get(key);

instrument.play();

}

System.out.println("------------Properties----------------");

for(Iterator iter = instruments4.keySet().iterator();iter.hasNext();){

String key = (String)iter.next();

System.out.println(key+" : " + instruments4.getProperty(key));

}

private Collection<Instrument> instruments;

public void setInstruments(Collection<Instrument> instruments) {

this.instruments = instruments;

}

private Collection<Instrument> instruments2;

public void setInstruments2(Collection<Instrument> instruments2) {

this.instruments2 = instruments2;

}

private Map<String,Instrument> instruments3;

public void setInstruments3(Map<String,Instrument> instruments3) {

this.instruments3 = instruments3;

}

private Properties instruments4;

public void setInstruments4(Properties instruments4) {

this.instruments4 = instruments4;

}

collection.xml配置文件：

<list>

</list>

</property>

<set>

</set>

</property>

<map>

</map>

</property>

<props>

<prop key="GUITAR">STRUM STRUM STRUM</prop>

<prop key="CYMBAL">CRASH CRASH CRASH</prop>

</props>

</property>

</bean>

</bean>

</bean>

<constructor-arg value="HUM HUM HUM"></constructor-arg>

</bean>

public class CollectionApp {

public static void main(String[] args){

ApplicationContext ctx = new ClassPathXmlApplicationContext("org/spring/beans/collection/collection.xml");

Performer performer = (Performer)ctx.getBean("Hank");

performer.perform();

}

自动装配：Spring提供了四种自动装配类型：

byName——试图在容器中寻找和需要自动装配的属性名相同的Bean(或ID)。如果没有找到相符的Bean，这个属性就没有被装配上。
byType——试图在容器中寻找一个与需要自动配置的属性类型相同的Bean，如果没有找到相符的Bean,这个属性就没有被装配。如果找到超过一个相符的Bean，会抛出org.springframework.bans.factory.UnsatisfiedDependencyException异常。
constructor——试图在容器中查找与需要自动装配的Bean的构造函数参数一致的一个或多个Bean,如果存在不确定bean或构造函数，容器会抛出异常org.springframework.bans.factory.UnsatisfiedDependencyException。
autodetect——首先尝试使用constructor来自动装配，然后使用byType方式，不确定性的处理与constructor方式和byType方式一样。

Bean范围化：

当在Spring中生命<bean>时，有声明Bean范围的选项。为了湿的每次都能产生一个新的Bean实例，可以声明Bean的scope属性为prototype。例如：

大部分情况保留范围化设置是默认的singleton，但是对于新的域对象实例，在使用Spring作为厂时，可能会使用prototype。

范围	完成任务
singleton	定义Bean的范围为每个Spring容器一个实例（默认值）
Prototype	允许Bean可以被多次实例化（使用一次就创建一个）
request	定义Bean的范围是HTTP请求。只有使用有web能力的Spring上下文（例如Spring MVC）时才有效
session	定义Bean的范围是HTTP会话。只有使用有web能力的Spring上下文（例如Spring MVC）时才有效
plobal-session	定义Bean的范围是全局HTTP会话。只有在portlet上下文中才有效