（Spring In Action）bean注入基础知识

Spring的使命：简化Java开发。

Spring为简化Java开发采取的4个关键策略：

①基于POJO的轻量级和最小侵入性编程；

②通过依赖注入和面向接口实现松耦合；

③通过切面和惯例进行声明式编程；

④通过切面和模板减少样板式代码；

Spring容器管理bean对象的生命周期和协作关系，Spring通过上下文对象将你对bean的配置加载进Spring容器，比如你在JavaConfig中配置，或者XML中，或者隐式配置（使用@Component等注解），这样容器就可以管理你的对象。

几种上下文对象：

① AnnotationConfigApplicationContext:从一个或多个基于java的配置类中加载上下文定义，适用于java注解的方式；@Configuration

② ClassPathXmlApplicationContext:从类路径下的一个或多个xml配置文件中加载上下文定义，适用于xml配置的方式；

③ FileSystemXmlApplicationContext:从文件系统下的一个或多个xml配置文件中加载上下文定义，也就是说系统盘符中加载xml配置文件；

④ AnnotationConfigWebApplicationContext:专门为web应用准备的，适用于注解方式；

⑤ XmlWebApplicationContext:从web应用下的一个或多个xml配置文件加载上下文定义，适用于xml配置方式。

bean的生命周期





JavaConfig

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

@Configuration
//不指定值默认扫描自己所在的包以及子包
@ComponentScan
public class CDPlayerConfig {

}

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

@Configuration
//指定特定的包作为基础包
@ComponentScan(basePackages = {"com.Chapter2"})
public class CDPlayerConfig2 {

}

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

import com.Chapter2.CompactDisc;

@Configuration
//指定为特定的类和接口
@ComponentScan(basePackageClasses = {CompactDisc.class})
public class CDPlayerConfig3 {

}

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

import com.Chapter2.CDPlayer;
import com.Chapter2.CompactDisc;
import com.Chapter2.SgtPeppers;

@Configuration //表明这个类是一个配置类，该类应该包含在Spring应用上下文中如何创建bean的细节。
public class CDPlayerConfig4 {
@Bean(name="lonelyHeartsClub")
public CompactDisc sgtPeppers() {
return new SgtPeppers();
}
@Bean
public CDPlayer cdPlayer() {
return new CDPlayer(sgtPeppers());
}
/*@Bean
public CDPlayer cdPlayer(CompactDisc compactDisc) {
//构造器注入
return new CDPlayer(compactDisc);
}*/
@Bean
public CDPlayer cdPlayer(CompactDisc compactDisc) {
CDPlayer cdPlayer = new CDPlayer(compactDisc);
//setter方法注入
cdPlayer.setCd(compactDisc);
return cdPlayer;
}
}

@Profile：多种环境下的不同bean

不同环境下的不同bean创建，每个profile代表一种环境，spring通过spring.profiles.active和spring.profiles.default属性来设置，如果active有设置值则是active，不然则是default设置的值，如果default也没有设置值，则@Profile定义的bean不会被创建。

有多种方式来设置这两个属性：

①作为DispatcherServlet的初始化参数；

②作为web应用的上下文参数；

③作为JNDI条目；

④作为环境变量；

⑤作为JVM的系统属性；

⑥在集成测试类上，使用@ActiveProfiles注解配置。

public interface Person {
public void speak();
}

@Component
@Profile("China")
//Profile是China才会实例化这个bean
public class Chinese implements Person {

public void speak() {
System.out.println("我说中文");
}

}

@Component
@Profile("England")
//Profile是England才会实例化这个bean
public class English implements Person {

public void speak() {
System.out.println("I speak english");
}

}

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes=ProfileConfig.class)
//集成测试类上，使用@ActiveProfiles注解设置
@ActiveProfiles({"England"/*,"China"*/})
public class ProfileTest {
@Autowired
Person p;

@Test
public void testProfile() {
p.speak();
}
}

输出：I speak english

@Conditional满足条件才创建bean

@Conditional用到带有@bean注解的方法上，只有满足条件，才创建bean。

只有matches方法返回true，bean才会创建。

@FunctionalInterface
public interface Condition {

/**
* Determine if the condition matches.
* @param context the condition context
* @param metadata metadata of the {@link org.springframework.core.type.AnnotationMetadata class}
* or {@link org.springframework.core.type.MethodMetadata method} being checked
* @return {@code true} if the condition matches and the component can be registered,
* or {@code false} to veto the annotated component's registration
*/
boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata);

}

public interface ConditionContext {

/**
* Return the {@link BeanDefinitionRegistry} that will hold the bean definition
* should the condition match.
*/
BeanDefinitionRegistry getRegistry();

/**
* Return the {@link ConfigurableListableBeanFactory} that will hold the bean
* definition should the condition match.
*/
ConfigurableListableBeanFactory getBeanFactory();

/**
* Return the {@link Environment} for which the current application is running.
*/
Environment getEnvironment();

/**
* Return the {@link ResourceLoader} currently being used.
*/
ResourceLoader getResourceLoader();

/**
* Return the {@link ClassLoader} that should be used to load additional classes.
*/
ClassLoader getClassLoader();

}

下面是一个例子：

public interface RunEnvironment {
public void where();
}

import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.env.Environment;
import org.springframework.core.io.ResourceLoader;
import org.springframework.core.type.AnnotatedTypeMetadata;

/**
* bean是否加载的条件
* @author hasee
*
*/
public class WindowsConditional implements Condition {

public boolean matches(ConditionContext context, AnnotatedTypeMetadata am) {
//可以检查bean定义
BeanDefinitionRegistry register = context.getRegistry();
//可以检查bean是否存在，甚至探查bean的属性
ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
//检查环境变量是否存在以及它的值是什么
Environment environment = context.getEnvironment();
//返回类加载器，可以检查类是否存在
ClassLoader classLoader = context.getClassLoader();
//检查所加载的资源
ResourceLoader resourceLoader = context.getResourceLoader();

String osName = context.getEnvironment().getProperty("os.name");
System.out.println(osName);
return osName.contains("Windows");
}

}

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;
/**
* bean是否加载的条件
* @author hasee
*
*/
public class LinuxConditional implements Condition {

public boolean matches(ConditionContext context, AnnotatedTypeMetadata arg1) {
String osName = context.getEnvironment().getProperty("os.name");
System.out.println(osName);
return osName.contains("Linux");
}

}

public class WindowsEnvironment implements RunEnvironment {

public void where() {
System.out.println("Run in Windows");
}

}

public class LinuxEnvironment implements RunEnvironment {

public void where() {
System.out.println("Run in Linux");
}

}

@Configuration
public class ConditionalConfig {
//spring会遍历下面的条件，只生成符合的bean

@Bean
//只有满足WindowsConditional的条件此类才加载
@Conditional(WindowsConditional.class)
public RunEnvironment getWindows() {
return new WindowsEnvironment();
}

@Bean
@Conditional(LinuxConditional.class)
public RunEnvironment getLinux() {
return new LinuxEnvironment();
}
}

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.Chapter3.conditional.config.ConditionalConfig;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes= {ConditionalConfig.class})
public class ConditionalTest {
@Autowired
private RunEnvironment runEnvironment;

@Test
public void conditionalTest() {
runEnvironment.where();
}
}
结果输出为：
Windows 8.1
Windows 8.1
Run in Windows