spring(2)装配Bean

最新推荐文章于 2022-08-15 13:49:59 发布

PacosonSWJTU

最新推荐文章于 2022-08-15 13:49:59 发布

阅读量9.4k

点赞数 1

分类专栏： (6)SpringInAction

本文链接：https://blog.csdn.net/PacosonSWJTU/article/details/51518337

版权

(6)SpringInAction 专栏收录该内容

39 篇文章 2 订阅

订阅专栏

【0】README

0）本文部分文字描述转自：“Spring In Action（中/英文版）”，旨在review spring(2)装配Bean 的相关知识；

1）在spring中，对象无需自己查找或创建与其所关联的其他对象。相反，容器负责把需要相互协作的对象引用赋予各个对象；

2）装配：创建应用对象之间协作关系的行为通常称为装配，这也是依赖注入（DI）的本质（干货——装配是依赖注入的本质）；

3）可以预热一下：在Spring中装配bean有多种方式：配置Spring容器最常见的三种方法；

【1】Spring配置的可选方案

1）Spring容器作用：负责创建应用程序中的bean 并通过DI 来协调对这些对象之间的关系；

2）当描述bean 如何进行装配时，Spring提供了3种主要的装配机制（mechanism）：

m1）在XML中进行显式配置；
m2）在java中进行显式配置；
m3）隐式的bean 发现机制和自动装配；

Attention）

A1）Spring的配置风格是可以互相搭配的，所以你可以选择使用XML 装配一些bean，使用Spring基于java 的配置（JavaConfig）来装配另一些bean，而剩下的bena可以让Spring自动发现；
A2）而原书作者建议：尽可能地使用自动配置的机制；而必须要显示配置bean的时候，原书作者推荐类型安全并且比XML 更加强大的 JavaConfig；
A3）最后，只有当你想要使用便利的xml 命名空间，并且在 JavaConfig 中没有同样的实现时，才应该使用 XML；

【2】自动化装配Bean（Spring最强大的装配技术）

1）intro：Spring从两个角度来实现自动化装配：

1.1）组件扫描：Spring会自动发现应用上下文中所创建的bean；

1.2）自动装配：Spring自动满足bena之间的依赖；

【2.1】创建可被发现的Bean

1）以CD作为DI 如何运行提供的荔枝。如果你不将CD 插入（注入）到CD 播放器中，那么CD 播放器其实是没有太大用处的；

2）创建Disc（唱片）接口和具体的唱片

对以上代码的分析（Analysis）：

A1）component注解表明：该类会作为组件类，并告知spring要为这个类创建bean.（干货——@Component注解的作用）

A2）组件扫描默认是不启用的。我们需要显式配置一下spring，从而命令它去寻找带有@Component注解的类，并为其创建bean；

3）利用 @ComponentScan 注解启用了组件扫描

package com.spring.chapter2;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan
public class CDPlayerConfig {
}

对以上代码的分析（Analysis）：

A1）类CDPlayerConfig 通过 java 代码定义了Spring的装配规则；

A2）类CDPlayerConfig 并没有显式地声明任何bean，只不过它使用了 @ComponentScan 注解，这个注解能够在Spring中启用组件扫描；（干货——@ComponentScan注解的作用）

A3）@ComponentScan注解：默认会扫描配置类相同的包。因为CDPlayerConfig 位于 com.spring.chapter2，那所以Spring将会扫描这个包及其所有子包，查找带有 @Component注解的类；

Attention）也可以使用XML来启用组件扫描；

<context:component-scan base-package="com.spring.chapter2">

4）接下来创建测试用例（JUnit测试）；

对以上代码的分析（Analysis）：

A1）该测试用例使用了 Spring 的 SpringJUnit4ClassRunner：以便在测试开始的时候自动创建 Spring的应用上下文；

A2）注解@ContextConfiguration：会告诉它需要在 CDPlayerConfig中加载配置；因为CDPlayerConfig 类中包含了@ComponentScan，所以最终的应用上下文应该包含JayChou bean；（干货——@ContextConfiguration注解的作用）

【2.2】为组件扫描的bean命名（自定义bean 名称）

1）默认的名称是：将类的第一个字母改为小写，就是bean 名称；

2）自定义bean名称：将期望的id 作为值传递给 @Component注解；如

@Component("jay chou")
public class JayChou implements Disc{

3）还有一种为bean 命名的方式，这种方式不使用 @Component注解，而使用java依赖注入规范中提供的 @Named注解来设置bean id：

@Named("jay chou")
public class JayChou implements Disc{

Attention）注解 @Named == 注解 @Component：在大多数case下，他们是可以互换的，但更喜欢用 Component；

（干货——@Named注解的作用）

【2.3】设置组件扫描的基础包

1）problem+solution：

1.1）problem：@ComponentScan注解会按照配置类（如CDPlayerConfig ）所在的包作为基础包进行扫描，但是，如果想扫描不同的包，该怎么做？

1.2）solution：为了指定不同的基础包，需要做的就是在 @ComponentScan 的value属性中指明包的名称：

@Configuration
@ComponentScan("com.spring.chapter1")
public class CDPlayerConfig { }

1.2.1）如果想更加清晰地表明想要设置的基础包，通过basePackage属性进行配置：
@Configuration
@ComponentScan(basePackage="com.spring.chapter1")
public class CDPlayerConfig { }
1.2.2）当然也可以设置多个基础包
@Configuration
@ComponentScan(basePackage={"com.spring.chapter1", "com.spring.chapter2"})
public class CDPlayerConfig { }

2）problem+solution：

2.1）problem：在上面的荔枝中，所设置的基础包是String类型的；这种方法是类型不安全的

2.2）solution：@ComponentScan注解还提供了另外一种方法，那就是将其指定为包中所包含的类或接口：
@Configuration
@ComponentScan(basePackageClasses={CDPlayer.class, DVDPlayer.class})
public class CDPlayerConfig { }

Attention）basePackage 被替换为了 basePackageClasses；而basePackageClasses 属性设置的数组包含了类。这些类所在的包将作为组件扫描的基础包；（这就会扫描多个包了）

3）我们需要一种方法：能够将组件扫描得到的bean 和他们的依赖装配在一起，自动装配就可以完成这项任务；

（干货——引入自动装配的概念）

【2.4】通过为bean 添加注解实现自动装配

1）自动装配定义：自动装配就是让Spring自动满足bean依赖的一种方法，在满足依赖的过程中，会在Spring 应用上下文中寻找匹配某个bean需求的其他bean；（干货——自动装配定义）

2）@Autowired注解： 为了声明要进行自动装配，我们可以借助Spring 的 @Autowired注解；

3）@Autowired注解的意义：它在构造器上添加了@Autowired注解，这表明当Spring创建了 CDPlayer bean的时候，会通过这个构造器来进行实例化并且会传入一个Disc类型的bean；（干货——@Autowired注解的作用）

public class CDPlayer implements MediaPlayer{
 private Disc disc;
 
 @Autowired
 public CDPlayer(Disc disc) {
  this.disc = disc;
 }
 
 public void play() {
  disc.play();
 }
}

对以上代码的分析（Analysis）：

A0）上述第4行代码的 @Autowired：该注解表明当Spring创建CDPlayer bean 的时候，会通过这个构造器来进行实例化并且会传入一个可设置给 Disc 类型的bean；

A1）注解@Autowired 不仅能够用在构造器上，还能用在属性的setter方法上；
@Autowired
 public void setDisc(Disc disc) {
  this.disc = disc;
 }
A2）实际上，注解 @Autowired 可以用在类的任何方法上；

4）如果没有匹配的bean，那么在应用上下文创建的时候，Spring会抛出一个异常；

4.1）为了避免抛出异常，可以将required设置为 false：将required 属性设置为false时，Spring 会尝试执行自动装配，但是如果没有匹配的bean的话，Spring将会让这个bean 处于未装配的状态；
@Autowired(required=false)
 public CDPlayer(Disc disc) {
  this.disc = disc;
 }
4.2）如果有多个bean满足依赖关系的话，Spring将会抛出异常，表明没有明确指定要选择哪个bean 进行自动装配；

5）注解@Inject：该注解来源于java 依赖注入规范，该规范同时还为我们定义了 @Named 注解；在自动装配中，Spring同时支持 @Inject 和 @Autowired，在大多数cases下，他们是可以互换的；（干货——@Inject注解的作用）

【2.5】验证自动装配

【3】通过java 代码装配bean

1）有时候自动化配置方案行不通，因此需要明确配置Spring；如，你想要将第三方库中的组件装配到你的应用中，在这种case下，是没有办法在它的类上添加 @Component 和 @Autowired 注解的，因此就不能使用自动化装配的方案了；

2）所以就要采用显式装配bean方式，有两种方案可以选择（scheme）： java 和xml；原书作者建议：在进行显式配置时，JavaConfig 是更好的方案，因为它更为强大，类型安全并且对重构友好；

【3.1】创建配置类

1）创建JavaConfig类的关键：在于为其添加 @Configuration注解，@Configuration注解表明这个类是一个配置类，该类应该包含在Spring应用上下文中如何创建bean的细节；（不能再干货——@Configuration注解的作用）

2）由于是显式配置，所以要remove掉 @ComponentScan注解；

【3.2】声明简单的bean

1）如何声明：要在 JavaConfig中声明bean，我们需要编写一个方法，这个方法会创建所需类型的实例，然后给这个方法添加 @Bean注解；

@Bean
 public Disc jaychou() {
  return new JayChou();
 }

对以上代码的分析（Analysis）：@Bean注解会告诉Spring 这个方法将会返回一个对象，该对象要注册为 Spring应用上下文中的bean；方法体中包含了最终产生bean实例的逻辑；（干货——@Bean注解的作用）

2）默认case下： bean 的ID 将与带有@Bean注解的方法名是一样的；本例中，其ID==jaychou；

2.1）可以自定义bean的ID：

@Bean(name="our jaychou")
 public Disc jaychou() {
  return new JayChou();
 }

【3.3】借助JavaConfig实现注入

1）problem+solution

1.1）problem：前面声明的 JayChou（Disc）自身没有其他依赖；现在要声明CDPlayer bean，它依赖与 JayChou，那么在 JavaConfig中，要如何将它们装配在一起呢？

1.2）solution：在 JavaConfig中装配bean的最简单方式就是引用创建bean的方法。如下面就是一种声明 CDPlayer的可行方法：
// defined in CDPlayer.
@Bean(name="our jaychou")
 public Disc jaychou() {
  return new JayChou();
 }   
 @Bean
 public CDPlayer cdPlayer() {
  return new CDPlayer(jaychou());
 }
对以上代码的分析（Analysis）：

A1）cdPlayer()方法与jaychou()方法有些区别：在这里并没有使用默认的构造器构建实例，而是调用了需要传入 Disc 对象的构造器来创建CDPlayer实例；

A2）看起来 Disc 是通过 jaychou()方法得到的，但case并非总是如此：因为jaychou()方法上添加了 @Bean注解，Spring将会拦截所有对它的调用，并确保直接返回该方法所创建的bean，而不是每次都对其进行调用；（干货中的干货——也即是对jaychou方法的多次调用都只会返回同一个bean，而不是多个bean）；

看个荔枝） cdPlayer方法返回的CDPlayer的Disc 对象与 anotherPlayer方法返回的CDPlayer的Disc 对象是同一个； （干货——在软件领域中，多个播放器player可以使用同一张唱片jaychou）

@Bean
 public CDPlayer cdPlayer() {
  return new CDPlayer(jaychou());
 }
 
 @Bean
 public CDPlayer anotherPlayer() {
  return new CDPlayer(jaychou());
 }

对以上代码的分析（Analysis）：

A1）默认情况下，Spring中的bean 都是单例的，我们并没有必要为第2个CDPlayer bena创建相同的 JayChou 唱片；

A2）总之一句话： Spring会拦截对 jaychou()方法的调用并确保返回的是 Spring所创建的bean，也就是Spring本身首次调用jaychou()方法所创建的bean；

Attention）

A1）需要提醒的是，我们在这里使用CDPlayer的构造器实现了 DI 功能，但是我们完全可以采用其他风格的DI 配置；比如，如果想通过Setter 方法注入Disc的话，代码像这个样子：
@Bean
 public CDPlayer cdPlayer(Disc disc) {
  CDPlayer cdPlayer = new CDPlayer(disc);
  cdPlayer.setDisc(disc);
  return cdPlayer;
 }
A2）带有@Bean 注解的方法可以采用任何必要的java 功能来产生bean实例。构造器和Setter 方法只是 @Bean方法的两个简单样例；

2）对@bean注解的另外一种理解方式

@Bean
public CDPlayer cdPlayer(Disc disc) {
	return new CDPlayer(disc);
}

对以上代码的分析（Analysis）：当Spring 调用cdPlayer()创建CDPlayer bean的时候，它会自动装配一个Disc 到配置方法中。通过这种方式引用其他的bean 通常是最佳的选择，因为它不会要求将 Disc 声明到同一个配置类中，在这里甚至没有要求 Disc 必须要在 JavaConfig中声明，实际上它可以通过组件扫描功能自动发现或通过XML 来进行配置；

【4】通过XML 装配bean

【4.1】创建XML 配置规范

1）在使用JavaConfig的时候，要创建一个带有 @Configuration注解的类，而在XML配置中，这意味着要创建一个XML 文件，并且要以<beans>元素为根；<beans>是spring-benas模式中的一个元素；

2）最为简单的Spring XML 配置如下图所示：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context">
<!-- configuration details go here -->
</beans>

对以上代码的分析（Analysis）：使用XML时，需要在配置文件的顶部声明多个 XML 模式（XSD）文件，这些文件定义了配置Spring的XML 元素；

Supplement）借助Spring Tool Suite 创建XML 配置文件：创建和管理Spring XML 配置文件的一种简便方式是使用Spring Tool Suit；（原书作者又一次打了ad，觉得有用的，可以down 下来玩玩）

【4.2】声明一个简单的<bean>

1）使用spring-beans模式中的另外一个元素：<bean>；><bean>元素类似于JavaConfig 中的 @Bean注解；

2）我们按照如下方式声明 Disc bean：（这里声明了一个很简单的bean，创建这个bean的类通过class 属性来指定，并且要使用全限定的类名）

<bean class="com.spring.chapter1.JayChou" />

对以上代码的分析（Analysis）：

A1）默认的bean id ：根据全限定类名来进行命名，在本例中default id == com.spring.chapter1.JayChou#0，#0是一个计数的形式，用来区分相同类型的其他bean；

A2）自定义bean id：
<bean id="mydiy" class="com.spring.chapter1.JayChou" />

Attention）

A1）减少繁琐： 为了减少xml 中繁琐的配置，只对那些需要按名字引用的bean 进行明确的命名；（比如你需要将对它引用注入到另一个bean中）；（干货——引入减少繁琐）

A2）当Spring发现这个 <bean>元素时，它将会调用其默认构造器来创建bean；在XML配置中，bean的创建更加被动；

A3）在这个简单的<bean>声明中，我们把bean的类型以字符串的形式设置在了 class属性中，谁知道它是对的还是不对的。。为了检查该字符串是否是实际的类型，借助Spring Tool Suit检查XML的合法性；（感觉这个原书作者在打ad 一样，hh）；

【4.3】借助构造器注入初始化bean

1）在XMl中声明DI时，具体到构造器注入，有两种配置方案（scheme）：

s1）<constructor-arg>元素；

s2）使用spring3.0 所引入的 c-命名空间；

2）构造器注入bean引用

scheme1）通过XML配置来实现 “CDPlayer 类需要依赖（引用） Disc的实现类” 的需求；
<bean id="cdPlayer" class="com.spring.chapter2.CDPlayer">
    <constructor-arg ref="jaychou" />
</bean>
<bean id="jaychou" class="com.spring.chapter2.JayChou">
</bean>

scheme2）通过c-命名空间来实现 “CDPlayer 类需要依赖（引用） Disc的实现类” 的需求；

step1）要使用spring 的c-命名空间的话，必须要在XML 的顶部声明其模式，如下所示：

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

step2）使用c-命名空间来声明构造器参数：

<bean id="cdPlayer" class="com.spring.chapter2.CDPlayer"
c:cd-ref="jaychou" />

Attention）下图描述了这个属性名是如何组合而成的？

problem+solution）

problem）

solution）我们使用参数在整个参数列表中的位置信息：

<bean id="cdPlayer" class="com.spring.chapter2.CDPlayer"
c:_0-ref="jaychou" />

对以上代码的分析（Analysis）：我们将参数的名称替换为 “0”（因为数字不能开头，所以加了下划线作为前缀）；使用索引（_0,_1,...）来识别构造器参数感觉比使用名字更好一些；

3）将字面量注入构造器中（即，构造器参数是String类型，而不是具体的java类型）

3.1）通过XML来装配

<bean id="leehom"
class="com.spring.chapter2.Leehom">
    <constructor-arg value="Sgt. Pepper's Lonely Hearts Club Band" />
    <constructor-arg value="The Beatles" />
</bean>

3.2）通过c-命名空间来装配

<bean id="leehom"
    class="com.spring.chapter2.Leehom"
    c:_title="Sgt. Pepper's Lonely Hearts Club Band"
    c:_artist="The Beatles" />

4）装配集合：这种case下，<constructor-arg>能够实现，而c-命名空间是不能够实现的；

solutions）

s1）最简单的方法是将列表设置为null：

s2）更好的解决方法是提供给一个磁道名称的列表：使用 <list>元素将其声明为一个列表：

s3）当然了，我们也可以使用<ref>元素替代 <value>，实现bean引用列表的装配：

看个荔枝）通过XML配置装配集合

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:c="http://www.springframework.org/schema/c"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
      http://www.springframework.org/schema/beans/spring-beans.xsd
      http://www.springframework.org/schema/aop
      http://www.springframework.org/schema/aop/spring-aop.xsd">

	<bean id="leehom" class="com.spring.chapter2.Leehom"
		c:_0="十八般武艺" 
		c:_1="Leehom Wang">
		<constructor-arg>
			<list>
				<value>Sgt. Pepper's Lonely Hearts Club Band</value>
				<value>With a Little Help from My Friends</value>
				<value>Lucy in the Sky with Diamonds</value>
				<value>Getting Better</value>
				<value>Fixing a Hole</value>
				<!-- ...other tracks omitted for brevity... -->
			</list>
		</constructor-arg>
	</bean>
</beans>

public class Leehom implements Disc {

	private String title;
	private String artist;
	private List<String> tracks;

	public Leehom() {}
	
	public Leehom(String title, String artist, List<String> tracks) {
		this.title = title;
		this.artist = artist;
		this.tracks = tracks;
	}

	public void setTitle(String title) {
		this.title = title;
	}

	public void setArtist(String artist) {
		this.artist = artist;
	}

	public void setTracks(List<String> tracks) {
		this.tracks = tracks;
	}

	public void play() {
		System.out.println("Playing " + title + " by " + artist);
		for (String string : tracks) {
			System.out.println("-track: " + string);
		}
	}

	@Override
	public String getName() {
		return artist;
	}
}

Attention）我们也可以用同样的方式使用<set>元素：<list>和 <set>的元素区别在于：当Spring创建要装配的集合时，所创建的是 java.util.Set 还是 java.util.List；如果是Set的话，那么重复的值都会被忽略掉，存放顺序也不会得以保证保证；不过无论在哪种case下，都可以用 <set> 或 <List> 来装配 List or Set 设置数组；

【4.4】设置属性（如何使用Spring XML实现属性注入）

1）该选择构造器注入还是属性注入呢？ 作为一个通用的规则，原书作者倾向于对强依赖使用构造器注入，而对可选性的依赖使用属性注入；

2）Spring为<constructor-arg> 元素提供了c-命名空间作为替代方案，同样，Spring提供了更加简洁的p-命名空间，作为<property>元素的替代方案；

2.1）为了启用p-命名空间，必须要在 XML 文件中与其他的命名空间一起对其进行声明；

2.2）利用p-命名空间，按照以下方式装配disc属性；

3）将字面量注入到属性中

3.1）新的Leehom 类如下所示：

3.2）通过<property>元素的value属性注入

3.3）通过spring的p-命名空间来实现注入

对以上代码的分析（Analysis）：

A1）与c-命名空间一样，装配bean 引用与装配字面量的唯一区别是： 是否带有“-ref”后缀，如果没有该后缀的话，所装配的就是字面量（如String类型）；（干货——装配bean 引用与装配字面量的唯一区别是：是否带有“-ref”后缀，如果没有该后缀的话，所装配的就是字面量）

A2）不能通过p-命名空间来装配集合；但可以使用 Spring util-命名空间中的一些功能来简化 Leehom bean；

step1）需要在XML 中声明util-命名空间及其模式

step2）util-命名空间所提供的功能之一是 <util:list>元素，它会创建一个列表的bean；

step3）通过<util:list>元素创建了List bean，现在，我们将磁道列表 bean（tracklist）注入到 Leehom 的tracks 属性中；

Attention）<util:list>元素只是 util-命名空间中的多个元素之一。下表列出了 util-命名空间提供的所有元素：

【5】导入和混合配置（如何将自动化配置，JavaConfig以及XML 配置混合并匹配在一起）

【5.1】在JavaConfig 中引用XML 配置

Supplement）即是，CDPlayer bean通过 JavaConfig 来创建（装配）；而Disc的实现类 JayChou bean 通过 XML配置来创建（装配）；

【5.2】在XML配置中引用 JavaConfig

PacosonSWJTU

关注

1
点赞
踩
8

收藏

觉得还不错? 一键收藏
9
评论
spring(2)装配Bean

【0】README0）本文部分文字描述转自：“Spring In Action（中/英文版）”，旨在review spring(2)装配Bean 的相关知识；1）在spring中，对象无需自己查找或创建与其所关联的其他对象。相反，容器负责把需要相互协作的对象引用赋予各个对象；2）装配：创建应用对象之间协作关系的行为通常称为装配，这也是依赖注入（DI）的本质（干货——装配是依赖注入
复制链接

扫一扫