wildfly: leyendo propiedades del directorio de configuración

Contamos con la mejor información que hemos encontrado por todo internet. Queremos que te sirva de ayuda y si deseas aportar alguna mejora hazlo con total libertad.

Solución:

Si desea leer explícitamente un archivo del directorio de configuración (p. Ej. $WILDFLY_HOME/standalone/configuration o domain/configuration) hay una propiedad del sistema con la ruta en ella. Simplemente haz System.getProperty("jboss.server.config.dir"); y agregue su nombre de archivo para obtener el archivo.

Sin embargo, no lo leerías como un recurso, así que …

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

Entonces el archivo se cargará por ti.

Además, dado que WildFly ya no se envía con soporte OSGi, no sé cómo te ayudaría la creación de un módulo OSGi aquí.

Aquí hay un ejemplo completo usando solo CDI, tomado de este sitio.

1. Cree y complete un archivo de propiedades dentro de la carpeta de configuración de WildFly

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

2. Agregue una propiedad del sistema al archivo de configuración de WildFly.

   $ ./bin/jboss-cli.sh --connect
   [[email protected]:9990 /] /system-property=application.properties:add(value=$jboss.server.config.dir/application.properties)
   

Esto agregará lo siguiente al archivo de configuración de su servidor (standalone.xml o domain.xml):

3. Cree el bean de sesión singleton que carga y almacena las propiedades de toda la aplicación

   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. Crea el calificador CDI. Usaremos esta anotación en las variables de Java en las que deseamos inyectar.

   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. Cree el método de productor; esto genera el objeto a inyectar

   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)  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. Por último, inyecte la propiedad en uno de sus beans CDI

   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;
       
   
   

Lo más simple que puedes hacer es correr standalone.sh con un -P opción que hace referencia a su archivo de propiedades (necesita una URL file:/path/to/my.properties, o poner el archivo en $WILDFLY_HOME/bin).

Luego, todas las propiedades del archivo se cargarán como propiedades del sistema.

Para inyectar propiedades de configuración en las clases de su aplicación, eche un vistazo a DeltaSpike Configuration, que admite diferentes fuentes de propiedades como propiedades del sistema, variables de entorno, entradas JNDI y oculta la fuente específica de su aplicación.

Alternativamente, para evitar configurar las propiedades del sistema (que serán globales en el sentido de ser visibles para todas las aplicaciones implementadas en su instancia de WildFly), también puede definir una fuente de propiedad personalizada para que DeltaSpike lea un archivo de propiedades desde cualquier ubicación dada, y estas propiedades será local para su aplicación.

Acuérdate de que puedes optar por la opción de agregar una reseña si te ayudó.

---

---

Utiliza Nuestro Buscador