2019独角兽企业重金招聘Python工程师标准>>> 
http://docs.spring.io/spring/docs/current/spring-framework-reference/htmlsingle/#beans-java-instantiating-container-web ##7.12 Java-based container configuration (基于java的容器配置) ###7.12.1 Basic concepts:@Bean and @Configuration spring对于新的java配置的支持的核心武器是@Configuration-annotated类以及@bean-annotated方法.
@Bean注解是来标记一个可以实例化,配置,初始化一个新的有spring-ioc容器管理的新的对象.这里有些像spring的xml配置中的
用@Configuration表明他的主要目标是作为bean定义的资源.另外,@Configuration类允许通过调用同一个类里面的@Bean标注的方法定义的内部bean依赖.最简单的@Configuration类用法如下:
@Configuration
public class AppConfig {
@Bean
public MyService myService() {
return new MyServiceImpl();
}
}
上面的AppConfig类等价于下面的
####Full @Configuration vs 'lite' @Beans mode? 当 @Bean方法出现在没有@Configuration注解标志的类中时,它们实际上是在'lite'模式下处理的.例如,在@Component类里或一个POJO类里定义的bean方法都认为是'lite';
不同于full @Confuguration,lite @Bean 方法不易申明内部bean依赖.一般在'lite'模式下,一个@Bean方法不能调用其他的@Bean方法.
只有使用在@Configuration类里的@Bean方法才是保证'full'模式经常被使用的好方法.它可以阻止相同的@Bean方法意外的被多次调用,并有助于减少在'lite'模式下很难被追踪的微妙的bugs.
@Bean和@Configuration注解会在以后的部分深入讨论.但是,首先让我们来了解使用java-based configuration来创建spring容器的几种方式吧. ###7.12.2 Instantiating the Spring container using AnnotationConfigApplicationContext(用AnnotationConfigApplicationContext来实例化spring上下文容器) 本节中的AnnotationConfigApplicationContext,是spring3.0的新加内容.这个ApplicationContext的变种实现,不仅能够接受@Configuration的类,还可以接受平常的@Component类和JSR-330元数据标注的类.
当@Configuration类作为输入类时,@Configuration类本身会注册为一个bean,且所有声明的@Bean方法也会注册为一个bean定义.
当@component和JSR-330类被提供时,他们会被注册为bean定义.并且所有的依赖注入元数据例如@Autowired或@Inject将会被使用在这些类需要的地方.
###简单的构造器 同实例化一个ClassPathXmlApplicationContext时使用spring xml文件一样,实例化一个AnnotationConfigApplicationContext时也会使用@Configuration类.它允许的spring容器完全不使用xml.
public static void main(String[] args) {
ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
MyService myService = ctx.getBean(MyService.class);
myService.doStuff();
}
和上文提到的一样,AnnotationConfigApplicationContext不止限于@Configuration类.任何@Componnet和用JSR-330标记的类都可以作为入参提供到构造器里,如下:
public static void main(String[] args) {
ApplicationContext ctx = new AnnotationConfigApplicationContext(MyServiceImpl.class, Dependency1.class, Dependency2.class);
MyService myService = ctx.getBean(MyService.class);
myService.doStuff();
}
以上认为MyServiceImpl, Dependency1 and Dependency2等类使用了spring依赖注入的注解如@Autowired.
####Building the container programmatically using register(Class...) 使用注册器来动态创建容器 一个AnnotationConfigApplicationContext可以被一个无参的构造器实例化并用register()方法进行注册.这个方式在动态构建一个AnnotationConfigApplicationContext是特别有用.
public static void main(String[] args) {
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
ctx.register(AppConfig.class, OtherConfig.class);
ctx.register(AdditionalConfig.class);
ctx.refresh();
MyService myService = ctx.getBean(MyService.class);
myService.doStuff();
}
####Enabling component scanning with scan(String ..) 可用组件扫描 要保证组件扫描,只如下标志你的@Configuration类即可:
@Configuration
@ComponentScan(basePackages = "com.acme")
public class AppConfig {
...
}
有经验的spring用户可以发现其用法和xml使用context命名空间相似:
在上面的例子中,com.acme包将被扫描,查找任意被@Component标志的类,这些类将注册为spring容器里的bean定义.
AnnotationConfigApplicationContext 暴露了scan(String..)方法,使其有component-scanning的功能.
public static void main(String[] args) {
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
ctx.scan("com.acme");
ctx.refresh();//进行注册
MyService myService = ctx.getBean(MyService.class);
}
记住@Configuratin类的元注解也是@Component,所以它们是组件扫描的候选者.在上面的例子中,默认AppConfig是在com.acme包里的,在调用scan()方法它会被扫描,在refrsh()方法之后所有的@Bean方法会被容器处理并注册为一个bean定义. ####Support for web applications with AnnotationConfigWebApplicationContext(对web应用的支持)
AnnotationConfigApplicationContext的WebApplicationContext的版本可以通过AnnotationConfigWebApplicationContext实现.当你配置spring的ContextLoaderListener servlet Listener,spring MVC DispatcherServlet时会非常有用.下面是一个典型的spring MVC的web应用配置的web.xml.记住context-param和init-param参数的使用.
contextClass
org.springframework.web.context.support.AnnotationConfigWebApplicationContext
contextConfigLocation
com.acme.AppConfig
org.springframework.web.context.ContextLoaderListener
dispatcher
org.springframework.web.servlet.DispatcherServlet
contextClass
org.springframework.web.context.support.AnnotationConfigWebApplicationContext
contextConfigLocation
com.acme.web.MvcConfig
dispatcher
/app/*
###7.12.3 使用@Bean注解 @Bean是一个方法级别的注解,且是xml中
你可以在用@Configuration或@Component标志的类里使用@Bean注解. ####Declaring a bean 声明一个bean 要申明一个bean,可以简单的用@Bean来标注一个方法.你可以在ApplicationContext中用这个方法的特定返回值类型来注册一个bean定义.默认,bean的名称同方法名相同.下面是使用@Bean方法申明的简单例子;
@Configuration
public class AppConfig {
@Bean
public TransferService transferService() {
return new TransferServiceImpl();
}
}
上面的配置等价于下面的spring xmlns
这两个申明都可以在ApplicationContext中注册transferService,限制这个实例类型为TransferServiceImpl:
transferService->com.acme.TransferServiceImpl
####Bean dependencies (Bean的依赖) 一个@bean标记的方法可以有任意数量的参数来描述构建这个bean所必需的依赖.例如如果我们的TransferService需要一个AccountRepository,我们可以通过方法参数来实现这个依赖.
@Configuration public class AppConfig {
@Bean
public TransferService transferService(AccountRepository accountRepository) {
return new TransferServiceImpl(accountRepository);
}
}
这个解决机制是基于构造器依赖注入的替代物,查看相关片段已查看更多细节.
Recieving lifecycle callbacks (接受生命周期回调)
任何被@Bean注解标记的类都支持常规的生命周期回调,并可以使用@PostConstruct和@PreDestroy注解.
常规的spring生命周期回调同样支持.如果一个bean实现了InitializingBean,DisposableBean或者Lifecycle,他们的表现方法会被容器调用.
也完全支持*Aware接口的标准的设置,如BeanFactoryAware,BeanNameAware,MessageSourceAware,ApplicationContextAware等.
这个@Bean注解支持指定的任意初始化和销毁回调方法,同spring xml元素里的init-mehod,destroy-method属性一致.
public class Foo {
public void init() {
// initialization logic
}
}
public class Bar {
public void cleanup() {
// destruction logic
}
}
@Configuration
public class AppConfig {
@Bean(initMethod = "init")
public Foo foo() {
return new Foo();
}
@Bean(destroyMethod = "cleanup")
public Bar bar() {
return new Bar();
}
}
一般而言,使用java配置定义的beans都有一个公共的可以被销毁回调调用的close或shutdown方法.如果你有一个公共的close或shutdown方法且你不希望在容器关闭时它们被调用,简单的在你的bean定义上加上@Bean(destroyMethos="")来屏蔽这个默认模式.你可能想这么做,通过默认的JNDI来获取资源但它的生命周期管理需要在应用之外.特别,DataSource需要这么处理,因为在Java EE应用服务中它是个众所周知的问题.
@Bean(destroyMethod="")
public DataSource dataSource() throws NamingException {
return (DataSource) jndiTemplate.lookup("MyDS");
}
另外,用@Bean标注的方法,你一般会选择使用动态JNDI查找策略:spring的JndiTemplate或JndiLocateDelegate helpers或者直接的JNDI InitialContext用法,而不是JndiObjectFactoryBean的变种.JndiObjectFactoryBean会强迫你将返回类型定义为FactoryBean而不是实际的目标类型,结果在其他@Bean方法中需要指定该bean提供资源时会很难交叉引用调用.
当然,在上个例子的Foo中,等同于下面在构造器中调用init()方法.
@Configuration
public class AppConfig {
@Bean
public Foo foo() {
Foo foo = new Foo();
foo.init();
return foo;
}
// ...
}
当你直接使用java时,你可以直接同你的对象来做任何事,且不需要依赖容器的生命周期.
###Specifying bean scope 指定bean的作用域 ####Using the @Scope annotation使用@Scope注解 你可以用指定你的用@Bean标记的bean定义有一个特定的作用域.你可以使用在Bean Scope节里的任意标准的作用域.
默认作用域是单例(singleton),但你可以用@Scope注解重写该作用域
@Configuration
public class MyConfiguration {
@Bean
@Scope("prototype")
public Encryptor encryptor() {
// ...
}
}
###@Scope and scoped-proxy 作用域和作用域代理 spring通过scopes proxies提供一个合适的方式来同作用域依赖工作.最简单创建代理这种代理的方式是使用XML配置时的aop:scoped-proxy/元素.用@Scope配置你的beans用proxyMode属性提供了相同的支持.默认是没有代理的(ScopedProxyMode.NO),你可以指定为ScopedProxyMode.TRAGET_CLASS或ScopedPrxoyMode.INTERFACES. 如果你要将scoped proxy从xml引用文档转为使用java配置的Bean,你可以如下使用:
@Bean
@SessionScope
public UserPreferences userPreferences() {
return new UserPreferences();
}
@Bean
public Service userService() {
UserService service = new SimpleUserService();
// a reference to the proxied userPreferences bean
service.setUserPreferences(userPreferences());
return service;
}
####自定义bean命名 一般,配置类使用@bean方法的名字作为该bean的名字.不过,这个功能可以使用name属性来重写.
@Configuration
public class AppConfig {
@Bean(name = "myFoo")
public Foo foo() {
return new Foo();
}
}
###Bean aliasing (Bean的别名) 同7.3.1'Naming beans'讨论的那样,有时要给单个的bean多个名字,这就是Bean aliasing.@Bean注解的name属性接受一个String数组,这样可以了.
@Configuration
public class AppConfig {
@Bean(name = { "dataSource", "subsystemA-dataSource", "subsystemB-dataSource" })
public DataSource dataSource() {
// instantiate, configure and return DataSource bean...
}
}
####Bean description bean描述 有时给bean提供详细的文本描述非常有帮助.特别是当这些bean暴露(通过JMX)出来以用于监控时. 你可以这样给一个Bean添加描述
@Configuration
public class AppConfig {
@Bean
@Description("Provides a basic example of a bean")
public Foo foo() {
return new Foo();
}
}
###7.12.4 Using the @Configuration annotation(使用@Configuration 注解) @Configuration是一个类级别的注解来标注该对象是一个bean定义的资源.@Configuration类通过@Bean注解方法来声明beans定义.调用@Configuration类的@Bean方法也可以用于定义内部bean依赖.
####Injecting inner-bean dependencies(注入内置的依赖) 当一个Bean有其他依赖时,你可以这样表示一个依赖有一个bean方法来调用其他bean:
@Configuration
public class AppConfig {
@Bean
public Foo foo() {
return new Foo(bar());
}
@Bean
public Bar bar() {
return new Bar();
}
}
在上面的例子中,foo的bean通过构造器注入来接受bar的引用;;
注:只有在@Configuration类使用@Bean注解申明的方法时,这种申明内部bean依赖的方法才有效.你不能在平常的@Component类里使用内部bean依赖.
####Lookup method injection(查找方法注入) 和以前提过的一样,查找方法注入是一个我们很少使用的高级功能.当一个单例bean有一个原生作用域依赖时,这点会很有用.为这种配置类型使用java配置,它为实现这个模式提供了一个合适的方式;
public abstract class CommandManager {
public Object process(Object commandState) {
// grab a new instance of the appropriate Command interface
Command command = createCommand();
// set the state on the (hopefully brand new) Command instance
command.setState(commandState);
return command.execute();
}
// okay... but where is the implementation of this method?
protected abstract Command createCommand();
}
使用java配置支持,你可以创建一个CommandManager的子类并使用这种方式来重写它的createCommand()方法,这样它就能查找一个新的command对象.
@Bean
@Scope("prototype")
public AsyncCommand asyncCommand() {
AsyncCommand command = new AsyncCommand();
// inject dependencies here as required
return command;
}
@Bean
public CommandManager commandManager() {
// return new anonymous implementation of CommandManager with command() overridden
// to return a new prototype Command object
return new CommandManager() {
protected Command createCommand() {
return asyncCommand();
}
}
}
貌似也要在@Configuration类中.一个单例bean有一个原生bean的引用. ####Further information about how java-based configuration works internally 基于java配置协同工作的更多信息 下面的例子,一个@Bean方法被调用两次:
@Configuration
public class AppConfig {
@Bean
public ClientService clientService1() {
ClientServiceImpl clientService = new ClientServiceImpl();
clientService.setClientDao(clientDao());
return clientService;
}
@Bean
public ClientService clientService2() {
ClientServiceImpl clientService = new ClientServiceImpl();
clientService.setClientDao(clientDao());
return clientService;
}
@Bean
public ClientDao clientDao() {
return new ClientDaoImpl();
}
}
clientDao()方法在clientService1()和clientService2()方法里分别调用一次.既然这个方法串讲一个新的ClientDaoImpl的实例并返回它,那么你应该期待两个实例(一个service一个).这个定义会出现问题:在spring里,实例bean默认是单例作用域.这个关键点在于,所有的@Configuration类在启动时都是用CGLIB代理的子类启动的.在子类中,子方法在父方法调用和创建新实例之前首先查找容器中缓存的bean.记住在spring3.2中,你不需要额外引用CGLIB的jar包了,因为它已经在org.springframework.cglib的包下了,并收到了spring核心jar包里了.
这个行为会根据作用域的不同而差异.我们只讨论单例情况.
因为CGLIB动态代理在启动时需要添加功能所以这里有些限制,特别是配置类必须不是final.但是,4.3之后,配置类中允许所有的构造器,包括使用了@Autowired的,或无参构造器来申明默认注入.
如果你更倾向于避免CGLIB强加的限制,可以考虑在非@Configuration类里申明@Bean方法,例如,使用@Component类替代.@Bean方法之间的交叉调用不会被拦截,所有你必须依赖构造器或方法级别的依赖注入.
###7.12.5 Composing java-based configurations 集成java配置 ####Using the @Import annotaion 就像
@Configuration
public class ConfigA {
@Bean
public A a() {
return new A();
}
}
@Configuration
@Import(ConfigA.class)
public class ConfigB {
@Bean
public B b() {
return new B();
}
}
现在,当你实例化上下文时不需要指定ConfigA.class或ConfigB.class,你只需明确的提供ConfigB的类.
public static void main(String[] args) {
ApplicationContext ctx = new AnnotationConfigApplicationContext(ConfigB.class);
// now both beans A and B will be available...
A a = ctx.getBean(A.class);
B b = ctx.getBean(B.class);
}
这种方法简化了容器实例化,因为只有一个类需要处理,而不需要开发者在构造期间记住大量的@Configuration类.
在spring 4.2中,@Import还支持常规组件类,与AnnotationConfigContext.register()方法相似.当你要避免组件扫描时,使用少量的配置类作为定义你们所有组件的关键点. ####Injecting dependencies on imported @Bean definitions 通过@Import来引入bean定义 上面的例子虽然很简洁,但仍可以其作用.在大多数实际场景里,bean会用其他配置文件里的依赖.当使用xml时,这不是问题.因为这里没有编译器,且可以简单的宣布ref="someBean",并相信spring会在容器初始化时解决好.当然,当使用@Configuration类时,在这种配置模式下java编译器会提出一些限制,就是这些引用的bean必须经过java语法的检验;
但是,解决这个问题很简单,就想我们之前讨论的,@Bean方法可以有任意数量的参数来描述bean的依赖.让我们讨论一个使用@Configuration类的真实场景,每个bean都有其他类中的依赖:
@Configuration
public class ServiceConfig {
@Bean
public TransferService transferService(AccountRepository accountRepository) {
return new TransferServiceImpl(accountRepository);
}
}
@Configuration
public class RepositoryConfig {
@Bean
public AccountRepository accountRepository(DataSource dataSource) {
return new JdbcAccountRepository(dataSource);
}
}
@Configuration
@Import({ServiceConfig.class, RepositoryConfig.class})
public class SystemTestConfig {
@Bean
public DataSource dataSource() {
// return new DataSource
}
}
public static void main(String[] args) {
ApplicationContext ctx = new AnnotationConfigApplicationContext(SystemTestConfig.class);
// everything wires up across configuration classes...
TransferService transferService = ctx.getBean(TransferService.class);
transferService.transfer(100.00, "A123", "C456");
}
这里有其他的方式来达到相同的效果.记住@Configuration类是容器里的其他bean.这意味着你也可以像其他bean一样利用@Autowired和@Value进行注入.
保证你用最简单的方式来注入依赖.@Configuration类会在容器初始化时就会处理,并强制要注入的依赖超出预期的过早初始化.如有可能,重组上个例子中的基于参数的注入.
另外,通过@Bean来处理BeanPostProcessor和BeanFactoryPostProcessor定义时要特别小心.他们一般要申明为静态Bean方法,无需触发到包含它们的配置类的实例化.另外,@Autowired和@Value不会对配置类自身其作用,因为它作为一个bean实例创建太早了.
@Configuration
public class ServiceConfig {
@Autowired
private AccountRepository accountRepository;
@Bean
public TransferService transferService() {
return new TransferServiceImpl(accountRepository);
}
}
@Configuration
public class RepositoryConfig {
private final DataSource dataSource;
@Autowired
public RepositoryConfig(DataSource dataSource) {
this.dataSource = dataSource;
}
@Bean
public AccountRepository accountRepository() {
return new JdbcAccountRepository(dataSource);
}
}
@Configuration
@Import({ServiceConfig.class, RepositoryConfig.class})
public class SystemTestConfig {
@Bean
public DataSource dataSource() {
// return new DataSource
}
}
public static void main(String[] args) {
ApplicationContext ctx = new AnnotationConfigApplicationContext(SystemTestConfig.class);
// everything wires up across configuration classes...
TransferService transferService = ctx.getBean(TransferService.class);
transferService.transfer(100.00, "A123", "C456");
}
spring4.3支持@COnfiguration类里的构造器注入.记住如果目标bean只有一个构造器,那就不需要指定@Autowired的值.上面的例子,Repository的构造器无需添加@Autowired注解.
在上面的例子中,使用@Autowired作用得当,并提供了理想的模块,但在表现注入的bean定义需要申明这方面仍有些模糊.例如,一个开发者查找ServiceConfig,你怎么能准确的知道@Autowired AccounRepository注入的bean是哪一个呢.它可能在代码中不明确,但却是最好的那个.Spring Tool Suite提供了一个工具,它可以画出所有需要注入bean的层次图表,可能是所有你需要的bean.当然,你的其他java IDE也可以轻易的发现所有的AccountRepository类的申明和使用,并快速的表明所有返回该类型的@Bean方法的位置.
当歧义没有被接受,你想用你的IDE直接导航到另一个@Configuration类中,可以考虑注入配置类本身:
@Configuration
public class ServiceConfig {
@Autowired
private RepositoryConfig repositoryConfig;
@Bean
public TransferService transferService() {
// navigate 'through' the config class to the @Bean method!
return new TransferServiceImpl(repositoryConfig.accountRepository());
}
}
在上面的例子中,AccountRepository定义的地方非常明确.但是,ServiceConfig现在和RepositoryConfig类耦合了,这是个折中.这个轻微耦合在使用基于接口或抽象类的@Configuration类时会减轻.思考以下:
@Configuration
public class ServiceConfig {
@Autowired
private RepositoryConfig repositoryConfig;
@Bean
public TransferService transferService() {
return new TransferServiceImpl(repositoryConfig.accountRepository());
}
}
@Configuration
public interface RepositoryConfig {
@Bean
AccountRepository accountRepository();
}
@Configuration
public class DefaultRepositoryConfig implements RepositoryConfig {
@Bean
public AccountRepository accountRepository() {
return new JdbcAccountRepository(...);
}
}
@Configuration
@Import({ServiceConfig.class, DefaultRepositoryConfig.class}) // import the concrete config!
public class SystemTestConfig {
@Bean
public DataSource dataSource() {
// return DataSource
}
}
public static void main(String[] args) {
ApplicationContext ctx = new AnnotationConfigApplicationContext(SystemTestConfig.class);
TransferService transferService = ctx.getBean(TransferService.class);
transferService.transfer(100.00, "A123", "C456");
}
现在ServiceConfig通过集成DefaultRepositoryConfig,其耦合度已降低;而内置的IDE工具仍有效,对开发者来说很容易获得RepositoryConfig实现的类型结构.通过这种方式,导航到@Configuration类和它们的依赖和一般的导航到易于接口的代码没有太大的差异.
Conditionally include @Configuration classes or @Bean methods
根据任意系统状态,用条件控制使@Configuration类或单个的@bean方法有效或无效很有用.一个平常的例子是当spring环境中只有一个特定的profile可用时,使用@Profile注解来启动beans.
@Profile注解实际上是使用更灵活的@Conditional注解实现的.这个@Conditional注解是特定的org.springframework.context.annotation.Condition的实现,表明在@Bean注册之前应该先询问它.
实现Condition接口提供了一个返回true或false的matches()方法.例如,这里有一个使用@Profile的Condition实际实现;
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
if (context.getEnvironment() != null) {
// Read the @Profile annotation attributes
MultiValueMap attrs = metadata.getAllAnnotationAttributes(Profile.class.getName());
if (attrs != null) {
for (Object value : attrs.get("value")) {
if (context.getEnvironment().acceptsProfiles(((String[]) value))) {
return true;
}
}
return false;
}
}
return true;
}
查看@Conditional的javadoc来获取更多内容.
####Combining java and Xml configuration 基础java和XML配置
spring的@Configuration类的支持并不打算100%的替代spring的xml配置.一些基础设施如spring的xml命名空间仍是解决容器配置的理想方式.当xml适使或必须时,你可以如此:可以用XML-centric的方式实例化你的容器,例如,ClassPathXmlApplicationContext,或者用"java-centric"方式使用AnnotationConfigApplicationContext或@ImportResource注解来引入需要的XML.
####XML-centric use of @Configuration classes 以xml为中心使用@Configuration
当你倾向于从xml里使用spring容器并以ad-hoc的方式引入@Configuration类.例如,如果已存在大量的使用spring XML的代码,那么在需求上创建@Configuration类和在xml里引入它们会更加容易.下面你会找到在"XML-centric"情景下使用@Configuration类的技巧;
记住@Configuration里的类最后都是容器里的bean定义.在这个例子,我们新建了一个名为AppConfig的@Configuration类,并在system-test-config.xml里作为
@Configuration
public class AppConfig {
@Autowired
private DataSource dataSource;
@Bean
public AccountRepository accountRepository() {
return new JdbcAccountRepository(dataSource);
}
@Bean
public TransferService transferService() {
return new TransferService(accountRepository());
}
}
system-test-config.xml:
jdbc.properties:
jdbc.username=sa
jdbc.password=
public static void main(String[] args) {
ApplicationContext ctx = new ClassPathXmlApplicationContext("classpath:/com/acme/system-test-config.xml");
TransferService transferService = ctx.getBean(TransferService.class);
// ...
}
注:在上面的system-test-config.xml里,AppConfig的
针对以上场景,你可以设置路径扫描;component-scan包含annotation-scan的功能,所以不需要annotation-scan,通过设置component-scan的base-package属性来定义;现在system-test-config.xml如下:
####@Configuration class-centric use of XML with @ImportResource 通过使用@ImportResource来引入xml文件,这个是java-centric的做法,该注解需指明xml文件的位置
@Configuration
@ImportResource("classpath:/com/acme/properties-config.xml")
public class AppConfig {
@Value("${jdbc.url}")
private String url;
@Value("${jdbc.username}")
private String username;
@Value("${jdbc.password}")
private String password;
@Bean
public DataSource dataSource() {
return new DriverManagerDataSource(url, username, password);
}
}
properties-config.xml
jdbc.properties
jdbc.url=jdbc:hsqldb:hsql://localhost/xdb
jdbc.username=sa
jdbc.password=
public static void main(String[] args) {
ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
TransferService transferService = ctx.getBean(TransferService.class);
// ...
}
然后我们可以像在xml里一样使用property-placeholder里的属性了.