Hi. Today I expirienced problem with @Value annotation in spring.
This annotation can be used to inject value from properties files in spring based applications.
I will show you a typical use case of this annotation, the problem I encountered and how I dealt with it.

foo.properties:

address=Warsaw

Foo.java:

package com.raphaelsolarski.value;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;

@Component
@PropertySource("classpath:foo.properties")
public class Foo {

    @Value("${address}")
    private String address;

    public String getAddress() {
        return address;
    }

}

FooTest.java:

package com.raphaelsolarski.value;

import com.raphaelsolarski.value.config.Config;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = Config.class)
public class FooTest {

    @Autowired
    private Foo foo;

    @Test
    public void shouldReturnPropertyValue() throws Exception {
        String actual = foo.getAddress();
        String expected = "Warsaw";
        Assert.assertEquals(expected, actual);
    }

}

The test will fail with the following error:

org.junit.ComparisonFailure: 
Expected :Warsaw
Actual   :${address}

There is a simple solution. We have to declare a PropertySourcesPlaceholderConfigurer bean somewhere in spring configuration of our application.

Config.java

package com.raphaelsolarski.value.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;

@Configuration
@ComponentScan("com.raphaelsolarski.value")
public class Config {

    @Bean
    public static PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer() {
        return new PropertySourcesPlaceholderConfigurer();
    }

}

Full code on github.com

In this post I show you how to add filter in two different kinds of spring based configurations.

Configuration by WebApplicationInitializer

package raphaelsolarski.config;

import org.springframework.web.WebApplicationInitializer;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.DispatcherServlet;
import raphaelsolarski.filter.MyFilter;
import javax.servlet.ServletContext;
import javax.servlet.ServletRegistration;

public class MyWebAppInitializer implements WebApplicationInitializer {

   public void onStartup(ServletContext container) {
       //here I can set up any kind of spring context -> xml/java...
       AnnotationConfigWebApplicationContext appContext = new AnnotationConfigWebApplicationContext();
       appContext.scan("raphaelsolarski");
       ServletRegistration.Dynamic registration = container.addServlet("dispatcher", new DispatcherServlet(appContext));
       registration.setLoadOnStartup(1);
       registration.addMapping("/");
       container.addFilter("My filter", MyFilter.class).addMappingForServletNames(null, false, "dispatcher");
       //or container.addFilter("My filter", MyFilter.class).addMappingForUrlPatterns(null, false, "/*");
   }

}

Configuration by AbstractAnnotationConfigDispatcherServletInitializer

package com.raphaelsolarski.config;

import com.raphaelsolarski.filter.MyFilter;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;
import javax.servlet.Filter;

public class MyDispatcher extends AbstractAnnotationConfigDispatcherServletInitializer{
   @Override
   protected Class<?>[] getRootConfigClasses() {
       return null;
   }

   @Override
   protected Class<?>[] getServletConfigClasses() {
       return new Class<?>[] {SpringConfig.class};
   }

   @Override
   protected String[] getServletMappings() {
       return new String[] {"/"};
   }

   @Override
   protected Filter[] getServletFilters() {
       return new Filter[] { new MyFilter() };
   }
}

In my first post I want show you how to simply configure Dispatcher Servlet with Spring without xml code.
I will cover three types of spring configuration you may want to use(I think about cofiguration of rest of application, not about dispatcher servlet).
Java annotations driven config, xml based and mixture of both of them.

In configuration I will WebApplicationInitializer interface and AbstractDispatcherServletInitializer class.
When you want to configure dispatcher servlet in java you probably should use one of them.

Configuration by implementing WebApplicationInitializer interface:

import org.springframework.web.WebApplicationInitializer;

public class MyWebApplicationInitializer implements WebApplicationInitializer {

    @Override
    public void onStartup(ServletContext container) {
        XmlWebApplicationContext appContext = new XmlWebApplicationContext();
        appContext.setConfigLocation("/WEB-INF/spring/dispatcher-config.xml");

        ServletRegistration.Dynamic registration = container.addServlet("dispatcher", new DispatcherServlet(appContext));
        registration.setLoadOnStartup(1);
        registration.addMapping("/");
    }

}

Configuration by extending AbstractDispatcherServletInitializer(for using xml based spring configuration):

public class MyWebAppInitializer extends AbstractDispatcherServletInitializer {

    @Override
    protected WebApplicationContext createRootApplicationContext() {
        return null;
    }

    @Override
    protected WebApplicationContext createServletApplicationContext() {
        XmlWebApplicationContext cxt = new XmlWebApplicationContext();
        cxt.setConfigLocation("/WEB-INF/spring/dispatcher-config.xml");
        return cxt;
    }

    @Override
    protected String[] getServletMappings() {
        return new String[] { "/" };
    }

}

Configuration by extending AbstractAnnotationConfigDispatcherServletInitializer class(for java based spring configuration):

public class MyWebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {

    @Override
    protected Class<?>[] getRootConfigClasses() {
        return null;
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[] { MyWebConfig.class };
    }

    @Override
    protected String[] getServletMappings() {
        return new String[] { "/" };
    }

}

Links:
http://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/web/WebApplicationInitializer.html
http://docs.spring.io/spring/docs/current/spring-framework-reference/html/mvc.html#mvc-container-config