Java .properties files as strongly typed classes

Question

Is there way to get properties files as strongly typed classes? I guess there are code generators but doing it with annotations would be much cooler.

What I mean is;

Answer 1

Something like JFig (ugly IMO), Commons Configuration or EasyConf?

Answer 2

I think this will solve your problem I have written on this property framework for the last year. It will provide of multiple ways to load properties, and have them strongly typed as well.

Have a look at http://sourceforge.net/projects/jhpropertiestyp/

It is open sourced and fully documented

Here is my short description from SourceForge:

JHPropertiesTyped will give the developer strongly typed properties. Easy to integrate in existing projects. Handled by a large series for property types. Gives the ability to one-line initialize properties via property IO implementations. Gives the developer the ability to create own property types and property io's. Web demo is also available, screenshots shown above. Also have a standard implementation for a web front end to manage properties, if you choose to use it.

Complete documentation, tutorial, javadoc, faq etc is a available on the project webpage.

Answer 3

There are countless of framework that achieve that for XML with various degree of configuration needed. The standard one bundled with Java is JaxB but it is not exactly a one liner xml persistence framework ...

The problem is that using properties file will only works better than XML (or JSON, ...) on the most trivial classes. When the class become a bit more complex, the properties file will become a nightmare. Another problem is that with trivial classes - there is not much difference between Xml and properties.

That means that the scope of the project will be rather limited. Mostly useful for project having loads of simple properties files.

In big application I worked with, strongly-type reading of properties file is done quite often using a simple factory-method.

 Foo foo = Foo.loadFrom("foo.properties");

 class Foo {
    static Foo loadFrom(String fileName) {
         Properties props = new Properties();
         props.load(...);

         Foo foo = new Foo();
         foo.setKeyFoo(props.get("KeyFoo"));
         ...
         return foo;
    }
   ...
 }

Answer 4

There is a somewhat similar project for doing configuration as statically typed files. It requires to declare an interface, but it fills in the implementation itself:

public interface AppConfig extends Config {
    long getTimeout ();
    URL getURL ();
    Class getHandlerClass ();
}

Answer 5

The OP would like to map a property file to a Java API such that each named property in the file corresponds to a similarly named getter method in the API. I presume that an application would then use this API to get property values without having to use property name strings.

The conceptual problem is that a property file is fundamentally not a statically typed entity. Each time someone edits a property file they could add new properties, and hence change the "type" of the property file ... and by implication, the signature of the corresponding API. If we checked that there were no unexpected properties when the Java app loaded the properties file, then we've got an explicit dynamic type-check. If we don't check for unexpected (e.g. misnamed) properties, we've got a source of errors. Things get even messier if you want the types of property values to be something other than a String.

The only way you could do this properly would be to invent the concept of a schema for a property file that specified the property names and the types of the property values. Then implement a property file editor that ensures that the user cannot add properties that conflict with the schema.

And at this point we should recognize that a better solution would be to use XML as the property file representation, an XML schema driven editor for editing property files, and JAXP or something like it to map the property file to Java APIs.

Answer 6

Yet another way is to use a data binding framework that does this. Even one that does not seem to directly support that could work: for example, Jackson JSON processor would allow this to be done by something like:

ObjectMapper m = new ObjectMapper(); MyBean bean = m.convertValue(properties, MyBean.class); // (note: requires latest code from trunk; otherwise need to write first, read back)

which works as long as entries in Properties map match logical bean properties, and String values can be converted to matching underlying values.