Spring IoC容器（四）容器、环境配置及附加功能

本文内容包括容器的@Bean 及 @Configuration 注解的使用、容器环境的配置文件及容器的附加功能（包括国际化消息、事件发布与监听）。

1 容器配置

在注解模式下，@Configuration 是容器核心的注解之一，可以在其注解的类中通过@Bean作用于方法上来配置Bean。xml 与注解模式可以混合在一起使用。

1.1 @Bean

作用类似于xml 配置文件中的<bean/>标签。可以在注解内标识bean名，也可定义一些列别名。

作用对象	@Component作用于类，@Bean作用于方法。
实现原理	@Component 通常通过类路径扫描来自动探测，自动装配到Spring容器中，而@Bean则是在标有该注解的方法中创建这个Bean。
自定义性	@Bean 的自定义性更强。例如引入第三方库中的类需要装配到Spring时，只能使用@Bean来实现。

表 @Bean 与 @Component的对比

通常是在@Configuration注解的类中来使用@Bean，这种被称为“Full模式”，相反，如果没在@Configuration注解的类中使用@Bean，则被称为“Lite模式”。

1.1.1 Lite 模式

lite 模式定义如下：

1）在非@Configuration标记（例如@Component或者没有任何Spring注解，但在该类中的某个方法上使用了@Bean）的类里定义的@Bean方法。

2）@Configuration(proxyBeanMethods=false)标记的类内定义的@Bean方法。

该模式相对于Full模式有以下限制：

不会被CGLIB代理，而是使用了原始的类类型。
该类的@Bean方法相互之间不能直接调用（如果直接调用会生成新的实例）。

//@Configuration(proxyBeanMethods = false)
public class LiteConfiguration {@Beanpublic Service liteService1() {System.out.println("liteService1 实例化");return new Service(){};}@Beanpublic Service liteService2() {System.out.println("liteService2 实例化" + liteService1());return new Service(){};}
}public class LiteTest {public static void main(String[] args) {ApplicationContext applicationContext = new AnnotationConfigApplicationContext(FullConfiguration.class,LiteConfiguration.class);Object fullService1 = applicationContext.getBean("full1");Object liteService1 = applicationContext.getBean("liteService1");System.out.println(fullService1);System.out.println(liteService1);}
}

图 Lite模式下，bean没有被代理

通常情况下，推荐使用Full模式。Lite模式可能更时候需要更快响应速度或资源受限时。

1.2 @Configuration

作用类似于xml配置文件中的<beans/>标签。可以在类里配置bean，及可以在类上配置bean的扫描路径。在同一个@Configuration注解的类中，@Bean标注的方法可以相互调用，且无论调用多少次，都只会生成一个单例bean（该bean的作用域要为单例）。

@Configuration
public class FullConfiguration {// 如果定义了别名，则默认名失效@Bean({"full1","full"})public Service fullService1() {System.out.println("fullService1 实例化");return new Service() {};}@Beanpublic Service fullService2() {// 直接调用了fullService1()方法，无论该方法在个类被调用多少次，都只会生成一个实例（单例）System.out.println("fullService2 实例化:" + fullService1());return new Service() {};}@Beanpublic Service fullService3() {// 这里直接调用了fullService1()方法System.out.println("fullService3 实例化:" + fullService1());return new Service() {};}
}

1.2.1 @Lookup 方法注入依赖 Look Method Injection

通过@Inject注入时，依赖只会被注入一次，即在该bean被初始化时。如果想实现每次都能获取一个新的bean，可以使用@Lookup注解。如果想动态获取一个被容器管理的Bean实例时很有用。

该注解核心思想时：使用抽象方法声明需要注入的Bean，Spring在运行时动态生成其子类并重新实现该抽象方法（cglib代理），从而实现原型Bean的注入。使用规则如下：

可以在@Lookup注解中指定bean的名字。
该方法要符合cglib 代理方法的规则（不能是private、static、final）。
如果想每次调用都生成新的bean，则对应的bean作用域不能为singleton。（适合生命周期较短的Bean）

@Component
@Scope(value = "prototype")
public class LookupService1 implements Service {
}@Component
public class LookupService2 implements Service {
}@Component
public class LookupManage {@Lookup("lookupService1")public Service lookupService() {return null;}
}@Configuration
@ComponentScan(basePackages = "lookup")
public class LookupConfiguration {public static void main(String[] args) {ApplicationContext context = new AnnotationConfigApplicationContext(LookupConfiguration.class);LookupService1 lookupService1 = context.getBean(LookupService1.class);LookupService2 lookupService2 = context.getBean(LookupService2.class);System.out.println("原型 lookupService1：" + lookupService1);System.out.println("原型 lookupService2：" + lookupService2);System.out.println("--------lookup---------");LookupManage lookupManage = context.getBean(LookupManage.class);System.out.println(lookupManage.lookupService());System.out.println(lookupManage.lookupService());}
}

1.2.2 @Import 依赖导入

可以在类上使用@Import注解来导入其他@Configuration注解的类，这些被导入的类与该类就组合成了一个整体（类之间的Bean可以相互依赖）。

@Configuration
public class Configuration1 {@Beanpublic Service1 service1(Service2 service2) {System.out.println("service1() service2:");Service1 service1 = new Service1();System.out.println("service1:" + service1);return service1;}
}@Configuration
public class Configuration2 {@Beanpublic Service2 service2(Service3 service3) {System.out.println("service2() service3:" + service3);Service2 service2 = new Service2();System.out.println("service2:" + service2);return service2;}
}@Configuration
@Import({Configuration1.class,Configuration2.class})
public class Configuration3 {@Beanpublic Service3 service3() {Service3 service3 = new Service3();System.out.println("service3:" + service3);return service3;}public static void main(String[] args) {ApplicationContext context = new AnnotationConfigApplicationContext(Configuration3.class);Service3 service3 = context.getBean(Service3.class);Service2 service2 = context.getBean(Service2.class);Service1 service1 = context.getBean(Service1.class);System.out.println("service1:" + service1);System.out.println("service2:" + service2);System.out.println("service3:" + service3);}
}

1.3 AnnotationConfigApplicationContext

用于创建和初始化基于Java配置类的容器。可以通过构造函数或register方法（参数为class类型，可以是有@Configuration、@Component注解的或者没有任何注解的类）来指定需要注册的bean。容器会将这些类注册为bean。

还可以通过scan方法来指定需要扫描的类路径。

使用了register或scan方法后，要使用其refresh方法来刷新容器。

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.register(ProfilesConfiguration.class);
context.refresh();
Service bean = context.getBean(Service.class);

1.4 xml 与注解混合使用

在代码中可以将注解与xml格式的bean配置文件混合在一起使用。可分为两种情况：1) 以XML为中心；2）以注解为中心。

1.4.1 以XML为中心

在代码中，以XML配置为主。需要使用注解形式配置的bean时，有两种方法：1）在xml中使用 <component-scan/>标签来指定需要扫描的类路径；2）在xml中将@configuration注解的类用<bean/>标签来配置，还必须加上<context:annotation-config/>标签。

<!--xml_center.xml-->
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beanshttps://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<!--    要让xml支持注解，必须加上这个--><context:annotation-config/><context:component-scan base-package="container.xml"/><bean class="container.xml.XMLConfiguration"/><bean class="container.xml.XMLService"><constructor-arg name="service1" ref="service1"/><property name="service2" ref="service2"/></bean>
</beans>@Configuration
public class XMLConfiguration {public XMLConfiguration() {System.out.println("XMLConfiguration实例化");}@Beanpublic Service1 service1() {System.out.println("service1 实例化");return new Service1();}public static void main(String[] args) {ApplicationContext context = new ClassPathXmlApplicationContext("xml_center.xml");XMLService xmlService = context.getBean(XMLService.class);System.out.println("xmlService:" + xmlService);Object service = context.getBean("service1");System.out.println("service:" + service);System.out.println("service2:" + xmlService.getService2());}
}

1.4.2 以注解为中心

在代码中，以注解为主，可以在有@Configuration注解的类上，加上@ImportResource注解，来指定xml配置文件的路径。

@Configuration
@ImportResource("classpath:annotate_center.xml")
public class AnnotateConfiguration {@Bean("service1")public Service service1(XMLService xmlService) {System.out.println("service1 xmlService:" + xmlService);return new Service() {};}public static void main(String[] args) {ApplicationContext context = new AnnotationConfigApplicationContext(AnnotateConfiguration.class);XMLService xmlService = context.getBean(XMLService.class);Object service1 = context.getBean("service1");System.out.println(service1);System.out.println("xmlService:" + xmlService);}
}

2 环境配置

Environment接口是对容器环境的一个抽象，它包括两个访问：概要文件和属性。

2.1 @Profile 概要文件

@Profile是一种将容器的bean按照不同配置进行分组的机制。用于指示一个或多个组件仅在某些特定的配置下被创建和初始化。

在该注解中可以使用逻辑运算符（与 & 或 | 非 !）。

@Configuration
public class ProfilesConfiguration {@Bean@Profile("dev & other")public Service devService() {System.out.println("实例化 devService");return new Service() {};}@Bean@Profile("prod")public Service prodService() {System.out.println("实例化 prodService");return new Service() {};}public static void main(String[] args) {AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();context.getEnvironment().setActiveProfiles("other","dev");context.register(ProfilesConfiguration.class);context.refresh();Service bean = context.getBean(Service.class);System.out.println(bean);}
}

2.2 property 环境属性

Environment 提供了在多种环境下搜索属性的接口。不同环境属性名相同时优先级如下：1）ServletConfig (例如DispatcherServlet上下文)。2）ServletContext参数（例如web.xml）。3）JNDI环境变量。４）JVM系统变量。５）JVM系统环境。

还可以使用@PropertySource 注解来引入自定义属性。

@Configuration
@PropertySource("/pro.properties")
public class PropertyConfiguration {public static void main(String[] args) {ApplicationContext context = new AnnotationConfigApplicationContext(PropertyConfiguration.class);String name = context.getEnvironment().getProperty("my.name");String address = context.getEnvironment().getProperty("my.address");System.out.println(name + ":" + address);}
}pro.properties文件：
my.name=Jon
my.address=China

3 附加功能

ApplicationContext类还实现了MessageSource(消息)、ApplicationEventPublisher(事件发布)等接口。让容器拥有了像事件发布与监听、消息国际化等附加功能。

3.1 MessageSource 消息国际化

要实现这个功能，必须注册一个ResourceBundleMessageSource类型的bean。创建该bean时，可以指定消息的资源包（properties格式的文件）及文件编码等信息。

如果要实现国际化消息，则需要创建对应地域的资源包。

message/exception.properties:
error=The argument {0} is big errormessage/message_en.properties:
info=info str 
content=message contentmessage/message_en.properties:
info=中文内容
content=消息内容@Configuration
public class MessageSourceConfiguration{@Beanpublic ResourceBundleMessageSource messageSource() {ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();messageSource.setDefaultEncoding("UTF-8");messageSource.setBasenames("message/message","message/exception");return messageSource;}public static void main(String[] args) {MessageSource messageSource = new AnnotationConfigApplicationContext(MessageSourceConfiguration.class);String info = messageSource.getMessage("info", null, Locale.ENGLISH);System.out.println("info:" + info);String error = messageSource.getMessage("error", new Object[]{"userName"}, Locale.ENGLISH);System.out.println("error:" + error);System.out.println(messageSource.getMessage("info", null, Locale.CHINESE));;}
}

3.2 事件发布与监听

可以自定义事件，需要继承ApplicationEvent类。使用@EventListener注解作用于方法上，参数为对应的事件类型来实现对该事件的监听，可以通过@EventListener注解的筛选表达式来对监听的事件进行筛选。返回值可以是void，也可以是事件类型，当为事件类型时，表示继续发布返回的事件。

监听事件时默认是同步的，即会阻塞其他监听器。可以使用@Async来使该监听方法成为异步监听，使用异步监听有以下限制；1）异常不会传递到调用者。2）建议（同步或异步都可以通过返回一个事件来继续发布事件）不要用返回值来再次发布事件，而是在方法内部手动发布事件。这是为了让事件代码更清晰及更好控制。

public class CustomEvent1 extends ApplicationEvent {public CustomEvent1(Object source) {super(source);}
}public class CustomEvent2 extends ApplicationEvent {public CustomEvent2(Object source) {super(source);}
}@Configuration
public class EventConfiguration {@EventListener(condition = "event.source == '测试1'")@Order(1)@Asyncpublic CustomEvent2 listener1A(CustomEvent1 customEvent1) {System.out.println("事件监听1A：" + customEvent1);return new CustomEvent2("测试2");}@EventListener(condition = "event.source != '测试1'")@Order(0)public void listener1B(CustomEvent1 customEvent1) {System.out.println("事件监听1B：" + customEvent1);}@EventListenerpublic void listener2(CustomEvent2 customEvent2) {System.out.println("事件监听2：" + customEvent2);}public static void main(String[] args) {ApplicationContext context = new AnnotationConfigApplicationContext(EventConfiguration.class);context.publishEvent(new CustomEvent1("测试1"));context.publishEvent(new CustomEvent1("测试2"));}
}

3.2.1 泛型与事件的监听

在监听事件时，可以通过事件类型来对事件进行筛选。但是因为泛型的擦除（在运行过程中无法获取实例的泛型类型），无法之间利用泛型来对事件进行筛选。可以让自定义事件类实现ResolvableTypeProvider接口，来对事件类的实例的类型进行处理，从而来实现通过泛型筛选事件。

public class GenericEvent<T> extends ApplicationEvent implements ResolvableTypeProvider {public GenericEvent(T source) {super(source);}@Overridepublic ResolvableType getResolvableType() {System.out.println("getClass():" + getClass());System.out.println("getSource():" + getSource());return ResolvableType.forClassWithGenerics(getClass(),ResolvableType.forInstance(getSource()));}
}@Configuration
public class GenericConfiguration {@EventListenerpublic void listenerOfString(GenericEvent<String> genericEvent) {System.out.println("string 监听");}@EventListenerpublic void listenerOfBoolean(GenericEvent<Boolean> genericEvent) {System.out.println("Boolean 监听");}public static void main(String[] args) {ApplicationContext context = new AnnotationConfigApplicationContext(GenericConfiguration.class);context.publishEvent(new GenericEvent<String>("string"));System.out.println("------------------------");context.publishEvent(new GenericEvent<Boolean>(false));}
}