Spring 3 Java Based Configuration with @Value

Springsource has released the Javaconfig Framework as a core component of Spring 3.0. There is a trend in the industry to move from XML meta data toward using more annotation driven meta data. I say pick your poison, as one can mess up either.

I do like the readability of using Java code for configuration. Reading the Java classes used for the configuration has a shorter learning curve than reading XML files. Also I can directly unit test my configuration.

The Example

File Highlights

The example code located in on github here. I am using eclipse m2eclipse and spring plugins, and I would recommend importing the project as a maven project.

The Java class used for configuration:

@Configuration
// spring config that loads the properties file
@ImportResource("classpath:/properties-config.xml")
public class AppConfig { /**
* Using property 'EL' syntax to load values from the
* jetProperties value
*/
private @Value("#{jetProperties['jetBean.name']}") String name;
private @Value("#{jetProperties['jetBean.price']}") Long price;
private @Value("#{jetProperties['jetBean.url']}") URL url; /**
* Create a jetBean within the Spring Application Context
* @return a bean
*/
public @Bean(name = "jetBean")
JetBean jetBean() {
JetBean bean = new JetBeanImpl();
bean.setName(name);
bean.setPrice(price);
bean.setUrl(url);
return bean;
} }

The highlights for this class:

  • @Configuration – Basic annotation for Java based configuration.
  • @ImportResource – Allows us to import a spring xml file to add more functionality to the configuration that this class is building.
  • @Value – Creates expression driven dependency injection.
  • @Bean – Create a bean managed by the spring container.

The properties-config.xml file:

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd"> <!-- define the properties file to use -->
<util:properties id="jetProperties"
location="classpath:/jet.properties" />
</beans>

One line that matters. Line number 8. Create a java.util.Properties instance with values loaded from the supplied properties file.

Other files such as the POJO’s and properties files are included in the example. They are very vanilla, so I did not include them in the post. The test case has some changes in it.

public class JetBeanTest {

    @Test
public void testJetBean() {
// create the spring container using the AppConfig
// @Configuration class
ApplicationContext ctx =
new AnnotationConfigApplicationContext(AppConfig.class);
JetBean jetBean = ctx.getBean(JetBean.class);
assertThat(jetBean.getName(), equalTo("Gulf Stream G550"));
assertThat(jetBean.getPrice(), equalTo(Long.valueOf(60000000)));
URL gulfstream;
try {
gulfstream =
new URL("http://www.gulfstream.com/products/g550/");
} catch (MalformedURLException e) {
// TODO Auto-generated catch block
fail("error creating URL");
throw new RuntimeException("error creating URL");
}
assertThat(jetBean.getUrl(), equalTo(gulfstream));
}
}

The main change is the new class AnnotationConfigApplicationContext which drives the creation of the Spring application context via Java configuration.

Recap

Use @Configuration to annotate your configuration class. Mark your beans with @Bean. The following annotations are supported:

  • @Configuration
  • @Bean
  • @DependsOn
  • @Primary
  • @Lazy
  • @Import
  • @ImportResource
  • @Value

Using @Value with Spring Expression Language

Now starts the crazy cool stuff. The @Value can be used on fields, methods and parameters. Plus, Spring Expression Language (SpEL) defines the ‘value’ through the syntax #{ < SpEL expression > }. The syntax can get a bit harry, but is incredibly powerful. In this example I have used SpEL to load values from the javaProperties java.lang.Properties Object with syntax like:

// jetProperties java.lang.Properties bean in context.
// jetBean.name value in the property file
@Value("#{jetProperties['jetBean.name']}") String name

Using @Value and SpEL gives you the functionality to do such things as: setting default values, accessing system level properties, logical operators, regex, mathematical operations.

To summarize as Uncle Ben said:

With great power there must come great responsibility.

Link to the example code located in on github here.

Much thanks to Chris Beams and his blog post on Springsource.

转自:http://chrislovecnm.com/2010/03/08/spring-3-java-based-configuration-with-value/

上一篇:java中最常用jar包的用途说明


下一篇:Testing with a mocking framework (EF6 onwards)