This week in Spring: July 12th, 2011

Engineering | Josh Long | July 13, 2011 | ...

Welcome back to another installment of "This Week in Spring." Today saw a new sunrise, and - more importantly - the release of vSphere 5, the next step in cloud infrastructure!

My head's still buzzing after the excitement that accompanied this morning's launch.
This - and the recent release of vFabric 5 - represent the next stage in cloud innovation, and a huge part of taking your applications to production, and to the cloud, with Spring.

    <LI>O'Reilly has published a fantastic roundup on the <a href = "http://radar.oreilly.com/2011/07/7-java-projects.html">seven Java projects that <EM…

Countdown to Grails 2.0: Static resources

Engineering | Peter Ledbrook | June 30, 2011 | ...

Web applications typically rely heavily on what we call static resources, such as Javascript, CSS and image files. In a Grails application, they are put into a project's web-app directory and then referenced from the HTML. For example,

<link rel="stylesheet" href="${resource(dir: 'css', file: 'main.css')}" type="text/css">

will create a link to the file web-app/css/main.css. All very straightforward. You might even think that the current support is more than sufficient for anyone's needs. What else would you want to do?

That's a good point. The answer depends on the complexity of your application, but let's start with the example CSS link above. Why do we have to type out the <link rel="..." href=...>? Just by looking at the extension, we know that the resource is a CSS file. We also know that CSS files should be linked into an HTML page using the…

This week in Spring: June 28th, 2011

Engineering | Josh Long | June 29, 2011 | ...

Welcome back to another installment of "This Week in Spring."

Lots of great stuff this week, as usual. When we compile this list, we trawl the internet looking for interesting stuff and try to bring it to you, digest style, in this weekly roundup. Some of the resources that we commonly check are Twitter, the SpringSource blogs, CloudFoundry.org, and Tomcat Expert,

We try to not miss anything, but we might. If you know of something that we've missed or think should be included, don't hesitate to ping your humble editors with any suggestions.

While SpringSource has a strong presence at numerous conferences and industry events, the premiere conference for Spring developers remains the SpringOne conference, held yearly in the United States. Work is well underway in planning the final program. Check out the SpringOne 2GX page to see news and activity, and to register, for the upcoming SpringOne2GX conference.

    <LI><a href="http://www.springsource.org/spring-social/news/1.0.0.rc1-released">Spring Social 1.0.0.RC1</a…

This week in Spring: June 21st, 2011

Engineering | Josh Long | June 22, 2011 | ...

Welcome back to yet another This Week in Spring. SpringSource is out in full force at JAX San Jose this week and we will be at OSCON, in July. These events are great avenues for us to connect with the userbase. As usual, we've got a nice complement of stuff to cover this week, so let's get to it!

          <LI>  There has been loads of interest and discussion surrounding last week's <a href="http://blog.springsource.com/2011/06/09/spring-framework-3-1-m2-released/">Spring 3.1 second milestone</a>.  Sam Brannen writes about the <a href="http://blog.springsource.com/2011/06/21/spring-3-1-m…

Spring 3.1 M2: Testing with @Configuration Classes and Profiles

Engineering | Sam Brannen | June 21, 2011 | ...

As Jürgen Höller mentioned in his post announcing the release of Spring 3.1 M2, the Spring TestContext Framework(*) has been overhauled to provide first-class testing support for @Configuration classes and environment profiles.

In this post I'll first walk you through some examples that demonstrate these new testing features. I'll then cover some of the new extension points in the TestContext framework that make these new features possible.

      Please note: this is a cross post from my company blog www.swiftmind.com.

Background

In Spring 2.5 we introduced the Spring TestContext Framework which provides annotation-driven integration testing support that can be used with JUnit or TestNG. The examples in this blog will focus on JUnit-based tests, but all features used here apply to TestNG as well.

At its core, the TestContext framework allows you to annotate test classes with @ContextConfiguration to specify which configuration files to use to load the ApplicationContext for your test. By default the ApplicationContext is loaded using the GenericXmlContextLoader which loads a context from XML Spring configuration files. You can then access beans from the ApplicationContext by annotating fields in your test class with @Autowired, @Resource, or @Inject

Defining the Future for Virtualized and Cloud Java

Engineering | Rod Johnson | June 14, 2011 | ...

Today I am proud to announce version 5 of our VMware vFabric™ application platform defining the future of enterprise Java for cloud and virtualized execution environments. vFabric blazes the path to new and modern cloud architectures by providing a modern programming model paired with next-generation platform services. A path that is not overgrown with the cruft and complexity of prior-generation technologies. With vFabric 5, VMware is ensuring that enterprise Java is ready to meet the challenges of tomorrow’s demanding, data-intensive, massively scalable applications.

vFabric 5 continues to provide the best place to run your Spring applications with vFabric tc Server and the ability to monitor and manage those production solutions with incredible intelligence via vFabric Hyperic. The platform also addresses the technical challenges of cloud computing head on, supporting new approaches to data management that enable applications to scale across elastic, geographically distributed cloud architectures with our vFabric GemFire and RabbitMQ

This week in Spring: June 14th, 2011

Engineering | Josh Long | June 14, 2011 | ...

Welcome back to another installment of "This Week in Spring," and what a week it's been! This last week saw the release of the Spring 3.1 M2 and vFabric 5! Lots of exciting stuff to talk about there, as well as general community news, so let's get to it!

  1. Today VMware announced the release of VMware vFabric 5, the application platform that defines the future of enterprise Java for cloud and virtualized execution environments. vFabric 5 contains many of the technologies that the Spring community is already familiar with including tc Server, Hyperic, GemFire, and RabbitMQ, but now adds some new technology.
    • Elastic Memory for Java (EM4J): a new capability for tc Server that provides a completely new level of coordination between the application server and the underlying virtual machine. EM4J uses the underlying vSphere virtualization to overcome some of the limitations of the Java's static memory heap.
    • Spring Insight Operations: leverages the same code-level tracing technology from the Spring Insight project but pulls together information from multiple application servers into a single console with roll-up views, drill downs, and historical comparisons ready for production systems.
    • SQLFire: vFabric SQLFire leverages the time-tested vFabric GemFire underpinnings providing data at memory speed and horizontal scale but vFabric SQLFire adds familiar and standard SQL and JDBC interfaces to the service.

    Rod Johnson discusses all the details of the release in his latest blog. Be sure to check out the latest release and try it out.

  2. Spring core lead Juergen Hoeller has announced that Spring 3.1.0 M2 has been released! At long last, the next step on the steady march to Spring 3.1 GA! The new release is as feature-packed as the last one, with a long list of major new features including (but definitely not limited to!) improved Java configuration support, XML-free and hassle-free Servlet 3.0-based Spring MVC application bootstrapping, new Builder APIs for JPA and Hibernate, and much, much more! Check out the release announcement here and get the bits from your build dependency management tool of choice or the download page
  3. <LI> Hot on the heels of the Spring 3.1 release announcement, <a href="http://blog.springsource.com/2011/06/10/spring-3-1-m2-configuration-enhancements/">Chris Beams chimes in</a> on the much-improved Java-centric configuration model in Spring 3.1, M2, even as compared to M1! The features are really starting to come together to make this one of the smoothest, well arranged releases, yet! </LI> 
    
    <lI> 
    

    Spring 3.1 M2 represents a marked improvement in core Spring, as well as Spring MVC! Rossen Stoyanchev chimes in to introduce the numerous (truly, you'll need to read the detailed blog to…

Spring 3.1 M2: Spring MVC Enhancements

Engineering | Rossen Stoyanchev | June 13, 2011 | ...

This post focuses on what's new for Spring MVC in Spring 3.1 M2. Here are the topics:

  • Code-based equivalent for the MVC namespace.
  • Customizable @MVC processing.
  • Programming model improvements.

A brief reminder that the features discussed here are in action at the Greenhouse project.

Code-based Configuration For Spring MVC

As Chris pointed out in his blog post last Friday, XML namespaces cut down configuration dramatically but also reduce transparency and sometimes flexibility. This holds true for the MVC namespace, which supports a number of customizations but not everything that's available. That means you are either able to use it or otherwise leave it. We believe code-based configuration has a solution for that and a path from simple to advanced.

Let's begin with this simple, familiar snippet:


<mvc:annotation-driven />

Although not required for using annotated controllers, <mvc:annotation-driven> does a number of useful things -- it detects the presence of a JSR-303 (Bean Validation) implementation and configures data binding with it, it adds a JSON message converter if Jackson JSON library is available, and a few other things that can save quite a bit of configuration.

Now let's match that with code-based configuration:


@Configuration
@EnableWebMvc
public class WebConfig {
}

Here @EnableWebMvc imports an @Configuration class that matches the goodness of <mvc:annotation-driven>. As simple as that.

The next step is to use an attribute in <mvc:annotation-driven> perhaps to provide a FormattingConversionService, or to add a sub-element perhaps configuring message converters, or to use other MVC namespace elements like <mvc:interceptors>, <mvc:resources>, etc.

Let's see how to do all of that in code-based configuration:


@Configuration
@EnableWebMvc
public class WebConfig extends WebMvcConfigurerAdapter {

    @Override
    public void addFormatters(FormatterRegistry registry) {
        // register converters and formatters...
    }

    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        // add message converters...
    }

    @Override
    public void configureInterceptors(InterceptorConfigurer configurer) {
        configurer.addInterceptor(new…

Spring 3.1 M2: Configuration Enhancements

Engineering | Chris Beams | June 10, 2011 | ...

As Juergen mentioned in his post yesterday, and as I've mentioned in my previous posts on 3.1 M1, one of the major themes of Spring 3.1 is completing our vision for code-based configuration in Spring. We think a modern enterprise Java application should have a choice between Java and XML as first class options for its configuration. In this post we'll see how Spring 3.1 M2 helps make this a reality.

Note that although Java-based configuration has been available since Spring 3.0, with this release it is now on par with many more of the XML-based features that have been developed over the…

Spring Framework 3.1 M2 released

Engineering | Juergen Hoeller | June 09, 2011 | ...

Spring Framework 3.1 M2 has been released this week, marking the end of the 3.1 milestone phase. We are moving on to the release candidate phase now, preparing for a feature-complete RC1 in July and a GA release in September.

3.1 M2 completes the work on several major themes started in 3.1 M1 back in February:

  • We've stabilized our environment abstraction and the environment profile mechanism. If you haven't given it a try already, now is a great time to check it out!

  • Our Java-based application configuration approach has changed from the @Feature approach in M1 to @Enable* annotations on regular @Configuration classes in M2.

  • The cache abstraction has been revised for delivering a minimal cache interaction SPI. Our declarative caching solution (@Cacheable etc) keeps sitting on top of it.

Get the Spring newsletter

Stay connected with the Spring newsletter

Subscribe

Get ahead

VMware offers training and certification to turbo-charge your progress.

Learn more

Get support

Tanzu Spring offers support and binaries for OpenJDK™, Spring, and Apache Tomcat® in one simple subscription.

Learn more

Upcoming events

Check out all the upcoming events in the Spring community.

View all