spring(2)装配Bean

标签：

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

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

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

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

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

package com.spring.chapter2;

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

@Configuration
@ComponentScan
public class CDPlayerConfig {
}

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

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

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

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

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

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

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

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

@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.1）problem：在上面的荔枝中，所设置的 基础包是String类型的；这种方法是类型不安全的

2.2）solution：@ComponentScan注解还提供了另外一种方法，那就是将其指定为包中所包含的类或接口：

@Configuration
@ComponentScan(basePackageClasses={CDPlayer.class, DVDPlayer.class})
public class CDPlayerConfig { }

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

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

A1）注解@Autowired 不仅能够用在构造器上，还能用在属性的setter方法上；

@Autowired
 public void setDisc(Disc disc) {
  this.disc = disc;
 }

A2）实际上， 注解 @Autowired 可以用在类的任何方法上；

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();
 }

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）；

@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 来进行配置；

<?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>

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

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

A2）自定义bean id：

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

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

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

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

s1）<constructor-arg>元素；

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

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

solutions）

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

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

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

<?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;
	}
}

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-命名空间来实现注入

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 属性中；

spring(2)装配Bean

标签：

原文地址：http://blog.csdn.net/pacosonswjtu/article/details/51518337