wildfly: reading properties from configuration directory

The simplest thing you can do is to run standalone.sh with a -P option referencing your properties file (you need a URL file:/path/to/my.properties, or put the file in $WILDFLY_HOME/bin).

Then all properties from the file will be loaded as system properties.

For injecting configuration properties into your application classes, have a look at DeltaSpike Configuration, which supports different property sources like system properties, environment variables, JNDI entries and hides the specific source from your application.

Alternatively, to avoid setting system properties (which will be global in the sense of being visible to all applications deployed to your WildFly instance), you can also define a custom property source for DeltaSpike reading a properties file from any given location, and these properties will be local to your application.

Here is a full example using just CDI, taken from this site.

1. Create and populate a properties file inside the WildFly configuration folder

   $ echo 'docs.dir=/var/documents' >> .standalone/configuration/application.properties
   

2. Add a system property to the WildFly configuration file.

   $ ./bin/jboss-cli.sh --connect
   [standalone@localhost:9990 /] /system-property=application.properties:add(value=${jboss.server.config.dir}/application.properties)
   

This will add the following to your server configuration file (standalone.xml or domain.xml):

<system-properties>
    <property name="application.properties" value="${jboss.server.config.dir}/application.properties"/>
</system-properties>

3. Create the singleton session bean that loads and stores the application wide properties

   import java.io.File;
   import java.io.FileInputStream;
   import java.io.IOException;
   import java.util.HashMap;
   import java.util.Map;
   import java.util.Properties;
   
   import javax.annotation.PostConstruct;
   import javax.ejb.Singleton;
   
   @Singleton
   public class PropertyFileResolver {
   
       private Logger logger = Logger.getLogger(PropertyFileResolver.class);
       private String properties = new HashMap<>();
   
       @PostConstruct
       private void init() throws IOException {
   
           //matches the property name as defined in the system-properties element in WildFly
           String propertyFile = System.getProperty("application.properties");
           File file = new File(propertyFile);
           Properties properties = new Properties();
   
           try {
               properties.load(new FileInputStream(file));
           } catch (IOException e) {
               logger.error("Unable to load properties file", e);
           }
   
           HashMap hashMap = new HashMap<>(properties);
           this.properties.putAll(hashMap);
       }
   
       public String getProperty(String key) {
           return properties.get(key);
       }
   }
   

4. Create the CDI Qualifier. We will use this annotation on the Java variables we wish to inject into.

   import java.lang.annotation.ElementType;
   import java.lang.annotation.Retention;
   import java.lang.annotation.RetentionPolicy;
   import java.lang.annotation.Target;
   
   import javax.inject.Qualifier;
   
   @Qualifier
   @Retention(RetentionPolicy.RUNTIME)
   @Target({ ElementType.METHOD, ElementType.FIELD, ElementType.CONSTRUCTOR })
   public @interface ApplicationProperty {
   
       // no default meaning a value is mandatory
       @Nonbinding
       String name();
   }
   

5. Create the producer method; this generates the object to be injected

   import javax.enterprise.inject.Produces;
   import javax.enterprise.inject.spi.InjectionPoint;
   import javax.inject.Inject;
   
   public class ApplicaitonPropertyProducer {
   
       @Inject
       private PropertyFileResolver fileResolver;
   
       @Produces
       @ApplicationProperty(name = "")
       public String getPropertyAsString(InjectionPoint injectionPoint) {
   
           String propertyName = injectionPoint.getAnnotated().getAnnotation(ApplicationProperty.class).name();
           String value = fileResolver.getProperty(propertyName);
   
           if (value == null || propertyName.trim().length() == 0) {
               throw new IllegalArgumentException("No property found with name " + value);
           }
           return value;
       }
   
       @Produces
       @ApplicationProperty(name="")
       public Integer getPropertyAsInteger(InjectionPoint injectionPoint) {
   
           String value = getPropertyAsString(injectionPoint);
           return value == null ? null : Integer.valueOf(value);
       }
   }
   

6. Lastly inject the property into one of your CDI beans

   import javax.ejb.Stateless;
   import javax.inject.Inject;
   
   @Stateless
   public class MySimpleEJB {
   
       @Inject
       @ApplicationProperty(name = "docs.dir")
       private String myProperty;
   
       public String getProperty() {
           return myProperty;
       }
   }
   

If you want to explicitly read a file from the configuration directory (e.g. $WILDFLY_HOME/standalone/configuration or domain/configuration) there's a system property with the path in it. Simply do System.getProperty("jboss.server.config.dir"); and append your file name to that to get the file.

You wouldn't read it as a resource though, so...

String fileName = System.getProperty("jboss.server.config.dir") + "/my.properties";
try(FileInputStream fis = new FileInputStream(fileName)) {
  properties.load(fis);
}

Then the file would be loaded for you.

Also, since WildFly doesn't ship with OSGi support anymore, I don't know how creating an OSGi module would help you here.