@Value annotations inside my Java class don't load values from .properties file

Question

Before asking this question I tried to follow the following questions which are similar:

Injecting Properties using Spring & annotation @Value

How can I inject a property value into a Spring Bean which was configured using annotations?

Loading up properties file to a class in Spring

However, in my case I am not using any web applications or Tomcat; I'm just trying to load a cluster.properties file into a regular Java project via Spring so I can then ingest dummy data into Accumulo. Also, I'm trying to load properties from a cluster.properties file, not from key value pairs defined in an xml file.

Using what I learned from the links above and lots of reading on Spring, here's what I have:

I created the following context.xml file:

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">

      <!-- Define the Spring Bean to load our cluster properties -->
      <bean id="props" class="accumuloIngest.LoadProperties"></bean>

    </beans>  

And here is a small snippet of what my cluster.properties file looks like:

    cluster.instance=instance
    cluster.username=user

    etc...

Next, I created the following Spring main method under the class MainApp.java:

    package accumuloIngest;

    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;

    public class MainApp {

        // Spring main method used to load a cluster.properties file with the Spring framework
        public static void main(String[] args) {
            ApplicationContext ctx = new ClassPathXmlApplicationContext("context.xml");
            LoadProperties myObj = LoadProperties.class.cast(ctx.getBean("props"));

            // Now print out the cluster.properties loaded by Spring to verify they aren't null
            StringBuffer springPropsBuffer = new StringBuffer();
            springPropsBuffer.append("Printing out cluster.properties read via Spring...");
            springPropsBuffer.append("\n\n");
            springPropsBuffer.append("instanceName= ");
            springPropsBuffer.append(myObj.getInstanceName());
            springPropsBuffer.append("\n");
            springPropsBuffer.append("userName= ");
            springPropsBuffer.append(myObj.getUserName());
            springPropsBuffer.append("\n");
            springPropsBuffer.append("password= ");
            springPropsBuffer.append(myObj.getPassword());
            springPropsBuffer.append("\n");
            springPropsBuffer.append("zooServers= ");
            springPropsBuffer.append(myObj.getZooServers());
            springPropsBuffer.append("\n");
            springPropsBuffer.append("tableName= ");
            springPropsBuffer.append(myObj.getTableName());
            springPropsBuffer.append("\n");
            springPropsBuffer.append("dataFile= ");
            springPropsBuffer.append(myObj.getDataFile());
            springPropsBuffer.append("\n");
            springPropsBuffer.append("dataDelim= ");
            springPropsBuffer.append(myObj.getDataDelim());
            springPropsBuffer.append("\n");
            springPropsBuffer.append("rowCount= ");
            springPropsBuffer.append(myObj.getRowCount());  
            springPropsBuffer.append("\n");
            System.out.println(springPropsBuffer.toString());

            // now start data ingest
            myObj.startIngest(); // method that calls Ingester class to start data ingest
        } // end of main method

    } // end of MainApp class

Spring loads my context.xml file and loads the Bean I called "props", but the values are still null. It seems that my @Value annotations aren't working in my LoadProperties class:

    package accumuloIngest;
    import java.io.IOException;

    import org.apache.accumulo.core.client.AccumuloException;
    import org.apache.accumulo.core.client.AccumuloSecurityException;
    import org.apache.accumulo.core.client.TableExistsException;
    import org.apache.accumulo.core.client.TableNotFoundException;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.beans.factory.config.PropertyPlaceholderConfigurer;
    import org.springframework.context.annotation.Bean;
    import org.springframework.core.io.ClassPathResource;
    import org.springframework.core.io.Resource;

    public class LoadProperties {

        // this class defines the Spring Bean and loads the cluster properties
        // using the SpringFramework

        @Bean
        public static PropertyPlaceholderConfigurer props(){
        PropertyPlaceholderConfigurer ppc = new PropertyPlaceholderConfigurer();
        Resource[] resource = new ClassPathResource[ ]
                { new ClassPathResource("/EclipseProjectName/src/cluster.properties") };
        ppc.setLocations(resource);
        ppc.setIgnoreUnresolvablePlaceholders(true);
        return ppc;
}

// Now load the properties from cluster.properties using the Spring Framework
private @Value("${cluster.instance}") String instanceName;
private @Value("${cluster.username}") String userName;
private @Value("${cluster.password}") String password;
private @Value("${cluster.zooServers}") String zooServers;
private @Value("${cluster.TableName}") String tableName;
private @Value("${cluster.DataFile}") String dataFile;
private @Value("${cluster.DataDelimiter}") String dataDelim;
private @Value("${cluster.rowCount}") int rowCount;

// Getters for the other Java classes to access properties loaded by Spring
public String getInstanceName() {
    return instanceName;
}
public String getUserName() {
    return userName;
}
public String getPassword() {
    return password;
}
public String getZooServers() {
    return zooServers;
}
public String getTableName() {
    return tableName;
}
public String getDataFile() {
    return dataFile;
}
public String getDataDelim() {
    return dataDelim;
}
public int getRowCount() {
    return rowCount;
}

        // method to kick off the ingest of dummy data
        void startIngest() {
            Ingester ingestObject = new Ingester();
            try {
                ingestObject.ingestData();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (TableNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (TableExistsException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (AccumuloException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (AccumuloSecurityException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } // end of try-catch block
        } // end of startIngest method

    } // end of LoadProperties class

Yet when I run MainApp.java in Eclipse the values are null when my Ingester.java class calls the getters.

Here's the console output when I run MainApp.java in Eclipse:

    13/09/24 14:08:24 INFO support.ClassPathXmlApplicationContext: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@191f667c: startup date [Tue Sep 24 14:08:24 EDT 2013]; root of context hierarchy
    13/09/24 14:08:24 INFO xml.XmlBeanDefinitionReader: Loading XML bean definitions from class path resource [context.xml]
    13/09/24 14:08:24 INFO support.DefaultListableBeanFactory: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@3cdd17f5: defining beans [props]; root of factory hierarchy
    Printing out cluster.properties read via Spring...

    instanceName= null
    userName= null
    password= null
    zooServers= null
    tableName= null
    dataFile= null
    dataDelim= null
    rowCount= 0

    Exception in thread "main" java.lang.IllegalArgumentException: argument was null:Is null- arg1? true arg2? true
        at org.apache.accumulo.core.util.ArgumentChecker.notNull(ArgumentChecker.java:36)
        at org.apache.accumulo.core.client.ZooKeeperInstance.<init>(ZooKeeperInstance.java:99)
        at org.apache.accumulo.core.client.ZooKeeperInstance.<init>(ZooKeeperInstance.java:85)
        at accumuloIngest.Ingester.ingestData(Ingester.java:65)
        at accumuloIngest.LoadProperties.startIngest(LoadProperties.java:69)
        at accumuloIngest.MainApp.main(MainApp.java:44)

Am I missing a piece of the Spring framework that loads the properties in my cluster.properties file? I had tried adding @AutoWired to both my MainApp and LoadProperties java classes but that didn't seem to help.

Answer 1

If you're going to use @Bean, you'll need @Configuration. You shouldn't declare a xml context to include an annotation context. You also shouldn't use your @Configuration class instance as a bean. ClassPathXmlApplicationContext is no good for processing annotation based configurations.

Use something like the following

@Configuration
@ComponentScan(basePackageClasses = LoadProperties.class)
public static class Config {
    @Bean
    public static PropertyPlaceholderConfigurer props() {
        PropertyPlaceholderConfigurer ppc = new PropertyPlaceholderConfigurer();
        Resource[] resource = new ClassPathResource[] { new ClassPathResource(
                "/EclipseProjectName/src/cluster.properties") };
        ppc.setLocations(resource);
        ppc.setIgnoreUnresolvablePlaceholders(true);
        return ppc;
    }  

    @Bean
    public LoadProperties loadProperties() {
        return new LoadProperties();
    }
}

public static class LoadProperties {
    private @Value("${cluster.zooServers}") String zooServers;
    ... // getters and setters
}

public static void main(String[] args) throws Exception {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
    LoadProperties load = (LoadProperties) context.getBean(LoadProperties.class);
    System.out.println(load.getZooServers());
}

A few things to note:

1. In your ClassPathResource you need to specify a classpath resource. Do you really have a resource /EclipseProjectName/src/cluster.properties at the root of your classpath? I very much doubt it.
2. In this case you won't need a @ComponentScan, but familiarize yourself with it.
3. A PropertyPlaceholderConfigurer needs to be declared static so it can be initialized before the other @Bean declarations. You should use PropertySourcesPlaceholderConfigurer as explained in the javadoc.