Comment un fichier JAR peut lire un externe fichier de propriétés

Nous avons un pool de connexion de composant (fichier JAR) pour l'un de notre application. À compter de maintenant, la connexion de l'application des détails sont fournis dans le fichier JAR (en .properties fichier).

Peut nous rendre plus générique? Pouvons-nous avoir le client dire le fichier de propriétés de détails (à la fois le chemin et le nom de fichier) et utiliser le POT pour obtenir la connexion?

Est-il judicieux d'avoir quelque chose comme ceci dans le code de client:

XyzConnection con = connectionIF.getConnection(uname, pwd);

Parallèlement à cela, le client devra indiquer (en quelque sorte???) le fichier de propriétés, détails qui ont la Url pour se connecter, le délai d'attente etc.

InformationsquelleAutor jai | 2010-08-11

8

http://www.javaworld.com/javaworld/javaqa/2003-08/01-qa-0808-property.html

plusieurs approches sont possibles, l'article ci-dessus fournit plus de détails
```
 ClassLoader.getResourceAsStream ("some/pkg/resource.properties");
 Class.getResourceAsStream ("/some/pkg/resource.properties");
 ResourceBundle.getBundle ("some.pkg.resource");
```
InformationsquelleAutor Aaron Saunders

Façon la plus simple, utilisez le commutateur-D à définir un système de propriété sur une ligne de commande java.
Que le système de la propriété peut contenir un chemin d'accès à votre fichier de propriétés.

E. g

java -cp ... -Dmy.app.properties=/path/to/my.app.properties my.package.App

Ensuite, dans votre code, vous pouvez le faire ( à l'exception de traitement n'est pas indiqué pour des raisons de concision ):

String propPath = System.getProperty( "my.app.properties" );

final Properties myProps;

if ( propPath != null )
{
     final FileInputStream in = new FileInputStream( propPath );

     try
     {
         myProps = Properties.load( in );
     }
     finally
     {
         in.close( );
     }
}
else
{
     //Do defaults initialization here or throw an exception telling
     //that environment is not set
     ...
}

InformationsquelleAutor Alexander Pogrebnyak

Il suffit de charger les propriétés de fichier, quelque chose comme

Properties properties = new Properties();
InputStreamReader in = null;
try {
     in = new InputStreamReader(new FileInputStream("propertiesfilepathandname"), "UTF-8");
     properties.load(in);
} finally {
     if (null != in) {
         try {
             in.close();
         } catch (IOException ex) {}
     }
}

Notez la façon dont le codage est explicitement spécifié en tant que UTF-8 ci-dessus. Il pourrait aussi être laissé de côté si vous acceptez la valeur par défaut de l'ISO8859-1 codage, mais méfiez-vous, avec tous les caractères spéciaux, puis.

InformationsquelleAutor Joonas Pulakka

C'est ma solution. D'abord la recherche de app.properties dans le dossier de démarrage, s'il n'existe pas essayer de le charger à partir de votre POT package:

File external = new File("app.properties");
if (external.exists())
    properties.load(new FileInputStream(external));
else 
    properties.load(Main.class.getClassLoader().getResourceAsStream("app.properties"));

InformationsquelleAutor tarn

Façon la plus simple est ci-dessous. Il se charge de l'application.propriétés de cfg dossier en dehors du fichier jar.

Structure De Répertoire

  |-cfg<Folder>-->application.properties
  |-somerunnable.jar

Code:

    Properties mainProperties = new Properties();
    mainProperties.load(new FileInputStream("./cfg/application.properties"));
    System.out.println(mainProperties.getProperty("error.message"));

InformationsquelleAutor Pratiyush Kumar Singh

Dans netbeans j'ai besoin de chargement de l'application.propriétés de conf/ dossier en dehors du fichier jar.

Donc j'ai écrit :

public static String getProperty(String FileName, String Prop)
{   

    try {  
        FIS = new FileInputStream( "./../conf/"+FileName);
        Properties properties;
        (properties = new Properties()).load(FIS);          

        for(Enumeration propKeys = properties.propertyNames();
                propKeys.hasMoreElements();){
            String tmpKey = (String) propKeys.nextElement();
            String tmpValue = properties.getProperty(tmpKey);                   

            tmpValue = tmpValue.trim();
            if (tmpKey.equals(Prop)){
                //System.out.println(tmpKey +"="+tmpValue);
                properties.put(tmpKey, tmpValue);
                Value = properties.getProperty(Prop);
                break;
            }

        }

        if (Value==null){
            throw new Exception("La Propiedad : "+Prop+" no Se encuentra en el Archivo de Configuracion");
        } 

    } catch (IOException e) {
        e.printStackTrace();
    } catch (Exception e) {
        e.printStackTrace();
    }
    return Value;

}

Pour Eclipse appliquer la suivante:

FIS = new FileInputStream( "../conf/"+FileName);

InformationsquelleAutor David Becerra Montellano

-1

public static String getPropertiesValue(String propValue) {
        Properties props = new Properties();
        fileType = PCLLoaderLQIOrder.class.getClassLoader().getResourceAsStream(propFileName);
        if (fileType != null) {
            try {
                props.load(fileType);
            } catch (IOException e) {
                logger.error(e);
            }
        } else {
            try {
                throw new FileNotFoundException("Property file" + propFileName + " not found in the class path");
            } catch (FileNotFoundException e) {
                logger.error(e);
            }
        }
        String propertiesValue = props.getProperty(propValue);
        return propertiesValue;
    }

méthodes ci-dessus fonctionne pour moi, il suffit de stocker vos biens fichier dans le répertoire à partir pour l'exécution de votre pot et de fournir ce nom à la place de propFileName, quand vous voulez, n'importe quelle valeur de la propriété appelez simplement getPropertyValue("name").

C'est illisible.

InformationsquelleAutor Naresh Kumar

Vous devez vous connecter pour publier un commentaire.