wildfly: Lesen der Eigenschaften von directory-Konfiguration

Hier ist ein komplettes Beispiel, mit nur CDI, aus diesem Website.

1. Erstellen und Auffüllen einer properties-Datei innerhalb des WildFly-Konfiguration Ordner

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

2. Fügen Sie eine system-Eigenschaft auf die WildFly-Konfigurationsdatei.

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

Diese fügen den folgenden, um Ihre server-Konfigurationsdatei (standalone.xml oder domain.xml):

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

1. Erstellen, die die singleton session bean, lädt und speichert die Breite Anwendung Eigenschaften

   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);
       }
   }

2. Erstellen der CDI-Qualifier. Wir werden mit dieser annotation im Java-Variablen, die wir wünschen einzuspritzen.

   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();
   }

3. Erstellen der producer-Methode; dies erzeugt das Objekt gespritzt werden

   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);
       }
   }

4. Schließlich Spritzen Sie die Immobilie in einen Ihrer 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;
       }
   }

Es klingt wie das problem, das Sie versuchen zu lösen, ist die Verwaltung unterschiedlicher (aber vermutlich ähnlich) Konfigurationsdateien für die Ausführung Ihrer Anwendung in verschiedenen Umgebungen (ie, Produktion, QA, oder sogar verschiedene Kunden). Wenn das der Fall ist, werfen Sie einen Blick auf Jfig http://jfig.sourceforge.net/ . Es würde vermeiden die Notwendigkeit für die Speicherung von property-Dateien außerhalb der classpath - (aber Sie konnte noch immer).

Was benötigt wird, ist ein hierarchischer Ansatz für die Konfiguration-Dateien. Neunzig Prozent der Konfiguration Werte, die ändern sich nicht aufrechterhalten werden kann, in eine base-Datei. Die anderen zehn Prozent (oder weniger) gepflegt werden dürfen, in Ihre eigene Konfigurationsdatei. Zur Laufzeit werden die Dateien überlagert auf der jeweils anderen, um eine flexible, überschaubare Konfiguration. Zum Beispiel in einer Entwicklungsumgebung myhost.config.xml vereint mit dev.config.xml und base.config.xml zu meinem einzigartigen Konfiguration.

Jede Konfigurationsdatei kann dann weiterhin in der version der Steuerung, da diese eindeutige Namen haben. Nur die base-Dateien geändert werden müssen, wenn die base-Werte ändern, und es ist leicht zu sehen, der Unterschied zwischen den Versionen. Ein weiterer großer Vorteil ist, dass änderungen an der Basis-Konfigurationsdatei wird ausführlich getestet, bevor die Bereitstellung.

Zu vermeiden, diese Art von problem, das Problem ist die Einstellung der jboss.server.config.dir im VM-Argumente wie :

-Djboss.server.config.dir="[jboss_repository]/server/[default-all-standard-standalone]/conf" –server