Annotation Type @bean,@Import,@configuration使用--官方文档
@Target(value={METHOD,ANNOTATION_TYPE})
@Retention(value=RUNTIME)
@Documented
public @interface BeanIndicates that a method produces a bean to be managed by the Spring container.Overview
The names and semantics of the attributes to this annotation are intentionally similar to those of the
<bean/>
element in the Spring XML schema. For example:@Bean
public MyBean myBean() {
// instantiate and configure MyBean obj
return obj;
}Bean Names
While a
name
attribute is available, the default strategy for determining the name of a bean is to use the name of the@Bean
method. This is convenient and intuitive, but if explicit naming is desired, thename
attribute may be used. Also note thatname
accepts an array of Strings. This is in order to allow for specifying multiple names (i.e., aliases) for a single bean.@Bean(name={"b1","b2"}) // bean available as 'b1' and 'b2', but not 'myBean'
public MyBean myBean() {
// instantiate and configure MyBean obj
return obj;
}Scope, DependsOn, Primary, and Lazy
Note that the
@Bean
annotation does not provide attributes for scope, depends-on, primary, or lazy. Rather, it should be used in conjunction with@Scope
,@DependsOn
,@Primary
, and@Lazy
annotations to achieve those semantics. For example:@Bean
@Scope("prototype")
public MyBean myBean() {
// instantiate and configure MyBean obj
return obj;
}@Bean
Methods in@Configuration
ClassesTypically,
@Bean
methods are declared within@Configuration
classes. In this case, bean methods may reference other@Bean
methods in the same class by calling them directly. This ensures that references between beans are strongly typed and navigable. Such so-called 'inter-bean references' are guaranteed to respect scoping and AOP semantics, just likegetBean()
lookups would. These are the semantics known from the original 'Spring JavaConfig' project which require CGLIB subclassing of each such configuration class at runtime. As a consequence,@Configuration
classes and their factory methods must not be marked as final or private in this mode. For example:@Configuration
public class AppConfig {
@Bean
public FooService fooService() {
return new FooService(fooRepository());
}
@Bean
public FooRepository fooRepository() {
return new JdbcFooRepository(dataSource());
}
// ...
}@Bean
Lite Mode@Bean
methods may also be declared within classes that are not annotated with@Configuration
. For example, bean methods may be declared in a@Component
class or even in a plain old class. In such cases, a@Bean
method will get processed in a so-called 'lite' mode.Bean methods in lite mode will be treated as plain factory methods by the container (similar to
factory-method
declarations in XML), with scoping and lifecycle callbacks properly applied. The containing class remains unmodified in this case, and there are no unusual constraints for the containing class or the factory methods.In contrast to the semantics for bean methods in
@Configuration
classes, 'inter-bean references' are not supported in lite mode. Instead, when one@Bean
-method invokes another@Bean
-method in lite mode, the invocation is a standard Java method invocation; Spring does not intercept the invocation via a CGLIB proxy. This is analogous to inter-@Transactional
method calls where in proxy mode, Spring does not intercept the invocation — Spring does so only in AspectJ mode.For example:
@Component
public class Calculator {
public int sum(int a, int b) {
return a+b;
} @Bean
public MyBean myBean() {
return new MyBean();
}
}Bootstrapping
See @
Configuration
Javadoc for further details including how to bootstrap the container usingAnnotationConfigApplicationContext
and friends.BeanFactoryPostProcessor
-returning@Bean
methodsSpecial consideration must be taken for
@Bean
methods that return SpringBeanFactoryPostProcessor
(BFPP
) types. BecauseBFPP
objects must be instantiated very early in the container lifecycle, they can interfere with processing of annotations such as@Autowired
,@Value
, and@PostConstruct
within@Configuration
classes. To avoid these lifecycle issues, markBFPP
-returning@Bean
methods asstatic
. For example:@Bean
public static PropertyPlaceholderConfigurer ppc() {
// instantiate, configure and return ppc ...
}By marking this method as
static
, it can be invoked without causing instantiation of its declaring@Configuration
class, thus avoiding the above-mentioned lifecycle conflicts. Note however thatstatic
@Bean
methods will not be enhanced for scoping and AOP semantics as mentioned above. This works out inBFPP
cases, as they are not typically referenced by other@Bean
methods. As a reminder, a WARN-level log message will be issued for any non-static@Bean
methods having a return type assignable toBeanFactoryPostProcessor
.
Optional Element Summary
Optional Elements Modifier and Type Optional Element and Description Autowire
autowire
Are dependencies to be injected via convention-based autowiring by name or type?String
destroyMethod
The optional name of a method to call on the bean instance upon closing the application context, for example aclose()
method on a JDBCDataSource
implementation, or a HibernateSessionFactory
object.String
initMethod
The optional name of a method to call on the bean instance during initialization.String[]
name
The name of this bean, or if plural, aliases for this bean.
Element Detail
name
public abstract String[] name
The name of this bean, or if plural, aliases for this bean. If left unspecified the name of the bean is the name of the annotated method. If specified, the method name is ignored.- Default:
- {}
autowire
public abstract Autowire autowire
Are dependencies to be injected via convention-based autowiring by name or type?- Default:
- org.springframework.beans.factory.annotation.Autowire.NO
initMethod
public abstract String initMethod
The optional name of a method to call on the bean instance during initialization. Not commonly used, given that the method may be called programmatically directly within the body of a Bean-annotated method.The default value is
""
, indicating no init method to be called.- Default:
- ""
destroyMethod
public abstract String destroyMethod
The optional name of a method to call on the bean instance upon closing the application context, for example aclose()
method on a JDBCDataSource
implementation, or a HibernateSessionFactory
object. The method must have no arguments but may throw any exception.As a convenience to the user, the container will attempt to infer a destroy method against an object returned from the
@Bean
method. For example, given an@Bean
method returning an Apache Commons DBCPBasicDataSource
, the container will notice theclose()
method available on that object and automatically register it as thedestroyMethod
. This 'destroy method inference' is currently limited to detecting only public, no-arg methods named 'close' or 'shutdown'. The method may be declared at any level of the inheritance hierarchy and will be detected regardless of the return type of the@Bean
method (i.e., detection occurs reflectively against the bean instance itself at creation time).To disable destroy method inference for a particular
@Bean
, specify an empty string as the value, e.g.@Bean(destroyMethod="")
. Note that theDisposableBean
and theCloseable
/AutoCloseable
interfaces will nevertheless get detected and the corresponding destroy/close method invoked.Note: Only invoked on beans whose lifecycle is under the full control of the factory, which is always the case for singletons but not guaranteed for any other scope.
- See Also:
ConfigurableApplicationContext.close()
- Default:
- "(inferred)
官方地址:
http://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/context/annotation/Bean.html
http://docs.spring.io/spring-javaconfig/docs/1.0.0.M4/reference/html/ch02s02.html
Annotation Type Import
@Target(value=TYPE)
@Retention(value=RUNTIME)
@Documented
public @interface ImportIndicates one or more@Configuration
classes to import.Provides functionality equivalent to the
<import/>
element in Spring XML. Only supported for classes annotated with@Configuration
or declaring at least one@Bean
method, as well asImportSelector
andImportBeanDefinitionRegistrar
implementations.@Bean
definitions declared in imported@Configuration
classes should be accessed by using@Autowired
injection. Either the bean itself can be autowired, or the configuration class instance declaring the bean can be autowired. The latter approach allows for explicit, IDE-friendly navigation between@Configuration
class methods.May be declared at the class level or as a meta-annotation.
If XML or other non-
@Configuration
bean definition resources need to be imported, use@ImportResource
官方地址:http://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/Import.html
Annotation Type Configuration
@Target(value=TYPE)
@Retention(value=RUNTIME)
@Documented
@Component
public @interface ConfigurationIndicates that a class declares one or more@Bean
methods and may be processed by the Spring container to generate bean definitions and service requests for those beans at runtime, for example:@Configuration
public class AppConfig {
@Bean
public MyBean myBean() {
// instantiate, configure and return bean ...
}
}Bootstrapping
@Configuration
classesVia
AnnotationConfigApplicationContext
@Configuration
classes are typically bootstrapped using eitherAnnotationConfigApplicationContext
or its web-capable variant,AnnotationConfigWebApplicationContext
. A simple example with the former follows:AnnotationConfigApplicationContext ctx =
new AnnotationConfigApplicationContext();
ctx.register(AppConfig.class);
ctx.refresh();
MyBean myBean = ctx.getBean(MyBean.class);
// use myBean ...See
AnnotationConfigApplicationContext
Javadoc for further details and seeAnnotationConfigWebApplicationContext
forweb.xml
configuration instructions.Via Spring
<beans>
XMLAs an alternative to registering
@Configuration
classes directly against anAnnotationConfigApplicationContext
,@Configuration
classes may be declared as normal<bean>
definitions within Spring XML files:<beans>
<context:annotation-config/>
<bean class="com.acme.AppConfig"/>
</beans>In the example above,
<context:annotation-config/>
is required in order to enableConfigurationClassPostProcessor
and other annotation-related post processors that facilitate handling@Configuration
classes.Via component scanning
@Configuration
is meta-annotated with@Component
, therefore@Configuration
classes are candidates for component scanning (typically using Spring XML's<context:component-scan/>
element) and therefore may also take advantage of@Autowired
/@Inject
at the field and method level (but not at the constructor level).@Configuration
classes may not only be bootstrapped using component scanning, but may also themselves configure component scanning using the@ComponentScan
annotation:@Configuration
@ComponentScan("com.acme.app.services")
public class AppConfig {
// various @Bean definitions ...
}See
@ComponentScan
Javadoc for details.Working with externalized values
Using the
Environment
APIExternalized values may be looked up by injecting the Spring
Environment
into a@Configuration
class using the@Autowired
or the@Inject
annotation:@Configuration
public class AppConfig {
@Inject Environment env; @Bean
public MyBean myBean() {
MyBean myBean = new MyBean();
myBean.setName(env.getProperty("bean.name"));
return myBean;
}
}Properties resolved through the
Environment
reside in one or more "property source" objects, and@Configuration
classes may contribute property sources to theEnvironment
object using the@PropertySources
annotation:@Configuration
@PropertySource("classpath:/com/acme/app.properties")
public class AppConfig {
@Inject Environment env; @Bean
public MyBean myBean() {
return new MyBean(env.getProperty("bean.name"));
}
}See
Environment
and@PropertySource
Javadoc for further details.Using the
@Value
annotationExternalized values may be 'wired into'
@Configuration
classes using the@Value
annotation:@Configuration
@PropertySource("classpath:/com/acme/app.properties")
public class AppConfig {
@Value("${bean.name}") String beanName; @Bean
public MyBean myBean() {
return new MyBean(beanName);
}
}This approach is most useful when using Spring's
PropertySourcesPlaceholderConfigurer
, usually enabled via XML with<context:property-placeholder/>
. See the section below on composing@Configuration
classes with Spring XML using@ImportResource
, see@Value
Javadoc, and see@Bean
Javadoc for details on working withBeanFactoryPostProcessor
types such asPropertySourcesPlaceholderConfigurer
.Composing
@Configuration
classesWith the
@Import
annotation@Configuration
classes may be composed using the@Import
annotation, not unlike the way that<import>
works in Spring XML. Because@Configuration
objects are managed as Spring beans within the container, imported configurations may be injected using@Autowired
or@Inject
:@Configuration
public class DatabaseConfig {
@Bean
public DataSource dataSource() {
// instantiate, configure and return DataSource
}
} @Configuration
@Import(DatabaseConfig.class)
public class AppConfig {
@Inject DatabaseConfig dataConfig; @Bean
public MyBean myBean() {
// reference the dataSource() bean method
return new MyBean(dataConfig.dataSource());
}
}Now both
AppConfig
and the importedDatabaseConfig
can be bootstrapped by registering onlyAppConfig
against the Spring context:new AnnotationConfigApplicationContext(AppConfig.class);
With the
@Profile
annotation@Configuration
classes may be marked with the@Profile
annotation to indicate they should be processed only if a given profile or profiles are active:@Profile("embedded")
@Configuration
public class EmbeddedDatabaseConfig {
@Bean
public DataSource dataSource() {
// instantiate, configure and return embedded DataSource
}
} @Profile("production")
@Configuration
public class ProductionDatabaseConfig {
@Bean
public DataSource dataSource() {
// instantiate, configure and return production DataSource
}
}See
@Profile
andEnvironment
Javadoc for further details.With Spring XML using the
@ImportResource
annotationAs mentioned above,
@Configuration
classes may be declared as regular Spring<bean>
definitions within Spring XML files. It is also possible to import Spring XML configuration files into@Configuration
classes using the@ImportResource
annotation. Bean definitions imported from XML can be injected using@Autowired
or@Import
:@Configuration
@ImportResource("classpath:/com/acme/database-config.xml")
public class AppConfig {
@Inject DataSource dataSource; // from XML @Bean
public MyBean myBean() {
// inject the XML-defined dataSource bean
return new MyBean(this.dataSource);
}
}With nested
@Configuration
classes@Configuration
classes may be nested within one another as follows:@Configuration
public class AppConfig {
@Inject DataSource dataSource; @Bean
public MyBean myBean() {
return new MyBean(dataSource);
} @Configuration
static class DatabaseConfig {
@Bean
DataSource dataSource() {
return new EmbeddedDatabaseBuilder().build();
}
}
}When bootstrapping such an arrangement, only
AppConfig
need be registered against the application context. By virtue of being a nested@Configuration
class,DatabaseConfig
will be registered automatically. This avoids the need to use an@Import
annotation when the relationship betweenAppConfig
DatabaseConfig
is already implicitly clear.Note also that nested
@Configuration
classes can be used to good effect with the@Profile
annotation to provide two options of the same bean to the enclosing@Configuration
class.Configuring lazy initialization
By default,
@Bean
methods will be eagerly instantiated at container bootstrap time. To avoid this,@Configuration
may be used in conjunction with the@Lazy
annotation to indicate that all@Bean
methods declared within the class are by default lazily initialized. Note that@Lazy
may be used on individual@Bean
methods as well.Testing support for
@Configuration
classesThe Spring TestContext framework available in the
spring-test
module provides the@ContextConfiguration
annotation, which as of Spring 3.1 can accept an array of@Configuration
Class
objects:@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes={AppConfig.class, DatabaseConfig.class})
public class MyTests { @Autowired MyBean myBean; @Autowired DataSource dataSource; @Test
public void test() {
// assertions against myBean ...
}
}See TestContext framework reference documentation for details.
Enabling built-in Spring features using
@Enable
annotationsSpring features such as asynchronous method execution, scheduled task execution, annotation driven transaction management, and even Spring MVC can be enabled and configured from
@Configuration
classes using their respective "@Enable
" annotations. See@EnableAsync
,@EnableScheduling
,@EnableTransactionManagement
,@EnableAspectJAutoProxy
, and@EnableWebMvc
for details.Constraints when authoring
@Configuration
classes- @Configuration classes must be non-final
- @Configuration classes must be non-local (may not be declared within a method)
- @Configuration classes must have a default/no-arg constructor and may not use
@Autowired
constructor parameters. Any nested configuration classes must bestatic
.
官方地址:http://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/context/annotation/Configuration.html
Annotation Type @bean,@Import,@configuration使用--官方文档的更多相关文章
- Spring Framework 官方文档学习(四)之Validation、Data Binding、Type Conversion(二)
接前一篇 Spring Framework 官方文档学习(四)之Validation.Data Binding.Type Conversion(一) 本篇主要内容:Spring Type Conver ...
- Spring Framework 官方文档学习(四)之Validation、Data Binding、Type Conversion
本篇太乱,请移步: Spring Framework 官方文档学习(四)之Validation.Data Binding.Type Conversion(一) 写了删删了写,反复几次,对自己的描述很不 ...
- Spring Framework 官方文档学习(四)之Validation、Data Binding、Type Conversion(一)
题外话:本篇是对之前那篇的重排版.并拆分成两篇,免得没了看的兴趣. 前言 在Spring Framework官方文档中,这三者是放到一起讲的,但没有解释为什么放到一起.大概是默认了读者都是有相关经验的 ...
- Spring Framework 官方文档学习(二)之IoC容器与bean lifecycle
到目前为止,已经看了一百页.再次感慨下,如果想使用Spring,那可以看视频或者找例子,但如果想深入理解Spring,最好还是看官方文档. 原计划是把一些基本接口的功能.层次以及彼此的关系罗列一下.同 ...
- TestNG官方文档中文版(2)-annotation
TestNG的官方文档的中文翻译版第二章,原文请见 http://testng.org/doc/documentation-main.html 2 - Annotation 这里是TestNG中用到的 ...
- TestNG官方文档中文版(2)-annotation(转)
1. 介绍 TestNG是一个设计用来简化广泛的测试需求的测试框架,从单元测试(隔离测试一个类)到集成测试(测试由有多个类多个包甚至多个外部框架组成的整个系统,例如运用服务器). 编写一个测试的 ...
- 微信小程序官方文档中表单组建button部分有关function(type)中type的个人理解
官方文档关于button组件的简介 xml页面挺容易理解,但js部分起初对整体写的形式都不太理解,随着逐渐阅读代码基本理解了 xml页面代码: <button type="defaul ...
- Spring 4 官方文档学习(十四)WebSocket支持
个人提示:如果需要用到页面推送,高频且要低延迟,WebSocket无疑是最佳选择.否则还是轮询和long polling吧. 做了一个小demo放在码云上,有兴趣的可以看一下,简单易懂:websock ...
- Spring JMS 官方文档学习
最后部分的XML懒得写了,因为个人更倾向于JavaConfig形式. 为知笔记版本见这里,带格式~ 做了一个小demo,放到码云上了,有兴趣的点我. 说明:需要先了解下JMS的基础知识. 1.介绍 S ...
随机推荐
- Python 学习笔记(2) - 基本概念、运算符与表达式
字符串 - 可以使用 3 种形式 - 单引号 :「'your string'」 - 双引号 :「"your string"」 - 三引号 :「'''your string''' 或 ...
- svn修改密码跟账户
在co的时候直接输入账户跟密码 svn co ${SVNURL} ./ --username **--password *** 或者删除缓存文件,在Linux上面 删除~/.subversion/a ...
- 静态代理VS动态代理
代理Proxy: Proxy代理模式是一种结构型设计模式,主要解决的问题是:在直接访问对象时带来的问题 代理是一种常用的设计模式,其目的就是为其他对象提供一个代理以控制对某个对象的访问.代理类负责为委 ...
- Contest 20140914 Mushroom写情书 字符串雙hash 後綴數組
0111:Mushroom写情书 查看 提交 统计 提问 总时间限制: 10000ms 内存限制: 256000kB 描述 有一天,Mushroom准备向他的GF表白,为了增加表白成功率,Mush ...
- BZOJ 3969 low power
Description 有\(n\)个机器,每个机器有\(2\)个芯片,每个芯片可以放\(k\)个电池.每个芯片能量是\(k\)个电池的能量的最小值.两个芯片的能量之差越小,这个机器就工作的越好.现在 ...
- MVC自学系列之二(MVC控制器-Controllers)
Controllers的职责 1.MVC模式中的Controllers的职责是对用户的输入做出响应,对用户的输入在实体上做一些变化.它关心的是应用的流动,处理传入的数据,并给相关的View提供数据 ...
- oracle索引再论
ORACLE中索引的数据结构有B树结构和位图结构. 我们通常用的普通索引.反向键索引.函数索引等都是B树结构的,是树状结构:位图结构则只有叶子节点. B树索引操作有唯一性扫描,范围扫描,快速索引全扫描 ...
- JavaScript高级程序设计18.pdf
系统对话框 alert().confirm()和prompt()调用系统对话框向用户显示消息,显示对话框的时候代码会停止执行,关闭后继续执行 alert()警告提示框 confirm()点击确认返回t ...
- 《University Calculus》-chape8-无穷序列和无穷级数-基本极限恒等式
基于基本的极限分析方法(诸多的无穷小以及洛必达法则),我们能够得到推导出一些表面上看不是那么显然的式子,这些极限恒等式往往会在其他的推导过程中用到,其中一个例子就是概率论中的极限定理那部分知识.
- Scrambled Polygon - POJ 2007(求凸包)
给一些点,这些点都是一个凸包上的顶点,以第一个点为起点顺时针把别的点拍排一下序列. 分析:最简单的极坐标排序了..................... 代码如下: ----------------- ...