Spring JavaConfig参考文档

http://dodomail.iteye.com/blog/125989

Spring JavaConfig参考文档
Spring JavaConfig Reference Documentation
官方地址: http://static.springsource.org/spring-javaconfig/docs/1.0-m2/reference/html/

Spring JavaConfig参考文档
Spring JavaConfig Reference Documentation
Rod Johnson
Costin Leau
version 1.0-m2
Copies of this document may be made for your own use and for distribution to others, provided that you do not
charge any fee for such copies and further provided that each copy contains this Copyright Notice, whether
distributed in print or electronically.
2007.05.08

目录
1. 介绍
2. 组件
2.1 @Configuration
2.2 @Bean
2.3 @ExternalBean
2.4 @ScopedProxy
3. Bean可见度
4. 装配依赖
5. 命名策略
6. 混合XM和annotations
7. 使用Java Configuration
8. Roadmap

第一章、介绍
在IoC中提到，Spring IoC核心为一个称为bean的概念。
这个概念定义了一个对象被Spring容器初始化、装配和管理的方式。
虽然Spring本身可以从任何metadata读取内容并装换成Java代码，但是XML是描述beans配置最流行的方式。
JDK5+中引入的Annotations允许源代码组件提供额外的metadata，这些metadata可以影响运行时语义。
这让annotations成为一个很好的配置选项。

第二章、组件
Java Configuration使用annotations来让开发人员不离开Java世界就可以创建和配置beans。
简短来说，开发人员使用Java代码来初始化和配置beans，然后指示容器使用它们。
在继续之前，请注意，Spring仍保持相同的语义，而不管采用何种配置方式: Java或者XML。
让我们看看JavaConfig依赖的最重要的annotations:

2.1 @Configuration
@Configuration标记指示配置类:

代码

@Configuration
public class WebConfiguration {
// bean definitions follow
}

代码

@Configuration(defaultAutowire = Autowire.BY_TYPE, defaultLazy = Lazy.FALSE)
public classDataSourceConfiguration extends ConfigurationSupport {}

2.2 @Bean
@Bean的名字暗示了一个bean定义(<bean/>标签)，让我们以一个简单的例子开始:

代码

@Bean (scope = DefaultScopes.SESSION)
public ExampleBean exampleBean() {
return new ExampleBean();
}

代码

@Bean
public ExampleBean exampleBean() {
return ExampleFactory.createBean();
}

代码

@Bean(aliases = {"anniversaries"})
public List<Date> birthdays() {
List<Date> dates = new ArrayList<Date>();
Calendar calendar = Calendar.getInstance();
calendar.set(1977, 05, 28);
dates.add(calendar.getTime());
dates.add(computeMotherInLawBirthday());
return dates;
}

代码

public class AwareBean implements BeanFactoryAware {
private BeanFactory factory;
// BeanFactoryAware setter
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
this.factory - beanFactory;
}
public void close() {
// do clean-up
}
}
@Bean(destroyMethodName = "close", lazy = Lazy.TRUE)
public AwareBean createBeanFactoryAwareBean() {
return new AwareBean();
}

2.3 @ExternalBean
@ExternalBean是一个简单的markup标记，它用来注入在父application context中定义的"外部"beans，让我们看看例子:

代码

@Configuration
public abstract class ExternalBeanConfiguration {
@Bean
public TestBean james() {
TestBean james = new TestBean();
// inject dependency from ann()
james.setSpouse(ann());
return james;
}
// Will be taken from the parent context
@ExternalBean
public abstract TestBean ann();
}

代码

@Configuration
public class ExternalBeanOnNormalMethod {
@ExternalBean
public TestBean ann() {
System.out.println("this code will not execute as the method " +
"will be overriden with a bean look up at runtime");
}
}

2.4 @ScopedProxy
Spring通过使用scoped proxies来提供方便的方式与scoped dependencies工作。
当使用XML配置时创建这样的proxy最简单的方式为<aop:scoped-proxy/>元素。
JavaConfig提供@ScopedProxy标记作为替换品，它提供相同的语义和配置选项。
参考文档里XML scoped proxy的例子在JavaConfig里看起来像这样:

代码

// a HTTP Session-scoped bean exposed as a proxy
@Bean(scope = DefaultScopes.SESSION)
@ScopedProxy
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可见度
JavaConfig的一个很好的特性是bean可见度。
JavaConfig使用方法可见度修饰符来决定从该方法得到的bean是否可以通过owning application context/bean factory来访问。
考虑如下配置:

代码

@Configuration
public abstract class VisibilityConfiguration {
@Bean
public Bean publicBean() {
Bean bean = new Bean();
bean.setDependency(hiddenBean());
return bean;
}
@Bean
protected HiddenBean hiddenBean() {
return new Bean("protected bean");
}
@Bean
private HiddenBean secretBean() {
Bean bean = new Bean("private bean");
// hidden beans can access beans defined in the 'owning' context
bean.setDependency(outsideBean());
}
@ExternalBean
public abstract Bean outsideBean()
}

代码

<beans>
<bean class="my.java.config.VisibilityConfiguration"/>
<bean class="org.springframework.config.java.process.ConfigurationPostProcessor"/>
<bean id="mainBean" class="my.company.Bean">
<property name="dependency" ref="publicBean"/>
<property name="anotherDependency" ref="hiddenBean"/>
</bean>
</beans>

四、装配依赖
为了装配一个bean，通常需要简单的使用Java提供的constructs:

代码

@Bean(scope = DefaultScopes.SINGLETON)
public Person rod() {
return new Person("Rod Johnson");
}
@Bean(scope = DefaultScopes.PROTOTYPE)
public Book book() {
Book book = new Book("Expert one-on-one J2EE Design and Development");
book.setAuthor(rod()); // rod() method is actually a bean reference !
return book;
}

代码

<bean id="rod" class="Person" scope="singleton">
<constructor-arg>Rod Johnson</constructor-arg>
</bean>
<bean id="book" class="Book" scope="prototype">
<constructor-arg>Expert One-on-On J2EE Design and Development</constructor-arg>
<property name="author" ref="rod" />
</bean>

代码

@Bean (scope = "customer")
public Bag shopingBag() {
return new Basket();
}
@Bean (scope = "shift")
public Manager shopManager() {
...
}

五、命名策略
到目前为止，上面所有的例子里，bean的名字都来自于方法名:

代码

@Configuration
public class ColorsConfiguration {
// create a bean with name 'blue'
@Bean
public Color blue() {
...
}
...
}
// dependency lookup for the blue color
applicationContext.getBean("blue");

代码

<bean class="org.springframework.config.java.process.ConfigurationPostProcessor">
<property name="namingStrategy">
<bean class="org.springframework.config.java.naming.MethodNameStrategy">
<property name="prefix" value="CLASS"/>
</bean>
</property>
</bean>

代码

// dependency lookup for the blue color using the new naming scheme
applicationContext.getBean("ColorsConfiguration.blue");

六、混合XML和annotations
Java和XML配置不是互斥的--它们可以同时在同一Spring程序里使用。为了从一个XML文件得到bean，我们需要使用Spring容器。
前面提到，我们可以使用@ExternalBean标记(推荐方式)。
当这种方式不适用时，可以访问@Configuration类使用的底层beanFactory。
这可以通过继承ConfigurationSupport或实现BeanFactoryAware接口来实现。
考虑下面的XML配置:

代码

<bean id="myBean" class="MyBean"/>

代码

@Configuration
public class MyConfig extends ConfigurationSupport {
@Bean
public ExampleBean anotherBean() {
ExampleBean bean = new ExampleBean("anotherBean");
bean.setDep(getBean("myBean")); // use utility method to get a hold of 'myBean'
return bean;
}
}
@Configuration
public class MyOtherConfig implements BeanFactoryAware {
private BeanFactory beanFactory;
public void setBeanFactory(BeanFactory beanFactory) {
// get access to the owning bean factory
this.beanFactory = beanFactory;
}
@Bean
public ExampleBean yetAnotherBean() {
ExampleBean bean = new ExampleBean("yetAnotherBean");
bean.setDep(beanFactory.getBean("myBean")); // use dependency lookup
return bean;
}
}

七、使用Java Configuration
为了使用annotations来配置我们的程序，我们可以使用:

a, AnnotationApplicationContext
它接收Ant风格模式的类名来搜索annotations:

代码

ApplicationContext config = new AnnotationApplicationContext(SimpleConfiguration.class.getName());
ApplicatonContext aBunchOfConfigs = new AnnotationApplicationContext("**/configuration/*Configuration.class");

b, Configuration post processor

代码

<beans>
<bean class="org.springframework.samples.petclinic.JdbcConfiguration"/>
<bean class="org.springframework.config.java.process.ConfigurationPostProcessor"/>
</beans>

代码

<beans>
<bean class="org.my.company.cofig.AppConfiguration">
<property name="env" value="TESTING"/>
<property name="monitoring" value="true"/>
<property name="certificates" value="classpath:/META-INF/config/MyCompany.certs"/>
</bean>
<bean class="org.springframework.config.java.process.ConfigurationPostProcessor"/>
</beans>

第八章、Roadmap
该project相对来说很年轻，可以认为是beta版(hence, the milestone release)。
后继的开发将关注于自动配置发现和简化。
反馈、八哥和建议在Srping forum和Spring issue tracking都是受欢迎的。

译者说:
Spring JavaConfig和Google Guice的区别主要在于它们两者的IoC理念不同:
JavaConfig说IoC配置是必须无侵入的，所以单独弄了个@Configuration
Guice说IoC配置是应用程序模型的一部分，所以配置都扔在领域模型代码中

最后感谢老婆公司领导命令她今天加班，译者今天才有一天的时间来翻译此文档。

JavaConfig和sannotations都以plugins的方式使用，Spring现在还没有集成它们，而JavaConfig是Spring的子项目，Spring要把Annotation配置集成到核心代码的话肯定选择JavaConfig了

你要采用annotation方式配置，就表示接受使用@Configuration

JavaConfig也提供了AOP的注解配置方式，不过文档中还没怎么提，不知道以后会不会替代AspectJ的注解方
式

Spring JavaConfig参考文档

Spring JavaConfig参考文档

猜你喜欢