Amorçage à ressort: est-il possible d'utiliser une application externe.les propriétés des fichiers dans des répertoires arbitraires avec un gros pot?

si vous n'avez pas modifié les valeurs par défaut de la botte de printemps (c'est-à-dire que vous utilisez @EnableAutoConfiguration ou @SpringBootApplication et que vous n'avez pas modifié la gestion des sources de propriété), alors elle cherchera des propriétés avec l'ordre suivant (le plus élevé l'emporte sur le plus bas):

1. a /config subdivision de l'annuaire courant
2. Le répertoire courant
3. Un classpath /config package
4. le chemin de La classe racine

la liste ci-dessus est mentionnée dans cette partie de la documentation

cela signifie que si une propriété est trouvée par exemple application.properties sous src/resources , elle sera remplacée par une propriété portant le même nom que celle trouvée dans application.properties dans le répertoire /config qui est" suivant " du bocal emballé.

cet ordre par défaut utilisé by Spring Boot permet une externalisation très facile de la configuration, qui à son tour rend les applications faciles à configurer dans plusieurs environnements (dev, staging, production, cloud etc)

pour voir l'ensemble des fonctionnalités fournies par la botte de printemps pour la lecture de propriétés (indice: il y a beaucoup plus disponible que la lecture de application.properties ) consultez cette partie de la documentation.

comme on peut le voir dans ma brève description au-dessus ou à partir de la documentation complète, les applications de démarrage à ressort sont très conviviales pour les développeurs!

tout est expliqué ici dans les docs:

http://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-external-config.html

ce qui explique que c'est l'ordre de priorité:

• /config sous répertoire du répertoire courant.
• Le répertoire courant
• paquet classpath /config
• le chemin de La classe racine

il souligne également que vous pouvez définir des fichiers de propriétés supplémentaires pour les dérogations comme cela:

java -jar myproject.jar 
    --spring.config.location=classpath:/overrides.properties

si vous utilisez spring.config.location , alors tous les emplacements par défaut pour application.properties sont également inclus. Cela signifie que vous pouvez configurer les valeurs par défaut dans application.properties et outrepasser comme requis pour un environnement particulier.

vous seriez en mesure de lancer votre application de démarrage de printemps avec le chemin du fichier de propriétés externes comme suit:

java -jar {jar-file-name}.jar 
--spring.config.location=file:///C:/{file-path}/{file-name}.properties

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <layout>ZIP</layout> 
            </configuration>
        </plugin>
    </plugins>
</build>

java -Dloader.path=file:///absolute_path/external.jar -jar example.jar

cela peut arriver en retard mais je pense que j'ai trouvé une meilleure façon de charger les configurations externes surtout quand vous utilisez votre application de démarrage à ressort en utilisant java jar myapp.war au lieu de @PropertySource ("classpath:some.propriétés")

la configuration serait chargée de la racine du projet ou de l'endroit où le fichier war/jar est lancé

public class Application implements EnvironmentAware {

    public static void main(String[] args) throws Exception {
        SpringApplication.run(Application.class, args);
    }

    @Override
    public void setEnvironment(Environment environment) {
        //Set up Relative path of Configuration directory/folder, should be at the root of the project or the same folder where the jar/war is placed or being run from
        String configFolder = "config";
        //All static property file names here
        List<String> propertyFiles = Arrays.asList("application.properties","server.properties");
        //This is also useful for appending the profile names
        Arrays.asList(environment.getActiveProfiles()).stream().forEach(environmentName -> propertyFiles.add(String.format("application-%s.properties", environmentName))); 
        for (String configFileName : propertyFiles) {
            File configFile = new File(configFolder, configFileName);
            LOGGER.info("\n\n\n\n");
            LOGGER.info(String.format("looking for configuration %s from %s", configFileName, configFolder));
            FileSystemResource springResource = new FileSystemResource(configFile);
            LOGGER.log(Level.INFO, "Config file : {0}", (configFile.exists() ? "FOund" : "Not Found"));
            if (configFile.exists()) {
                try {
                    LOGGER.info(String.format("Loading configuration file %s", configFileName));
                    PropertiesFactoryBean pfb = new PropertiesFactoryBean();
                    pfb.setFileEncoding("UTF-8");
                    pfb.setLocation(springResource);
                    pfb.afterPropertiesSet();
                    Properties properties = pfb.getObject();
                    PropertiesPropertySource externalConfig = new PropertiesPropertySource("externalConfig", properties);
                    ((ConfigurableEnvironment) environment).getPropertySources().addFirst(externalConfig);
                } catch (IOException ex) {
                    LOGGER.log(Level.SEVERE, null, ex);
                }
            } else {
                LOGGER.info(String.format("Cannot find Configuration file %s... \n\n\n\n", configFileName));

            }

        }
    }

}

J'espère que ça aidera.

une autre méthode flexible utilisant classpath contenant de la graisse jar (- cp fat.jar) ou tous les jars (-cp "$JARS_DIR/*") et un autre classpath de configuration personnalisé ou un dossier contenant des fichiers de configuration habituellement ailleurs et à l'extérieur de jar. Ainsi, au lieu du java-jar limité, utilisez la méthode classpath plus flexible comme suit:

java \
   -cp fat_app.jar \ 
   -Dloader.path=<path_to_your_additional_jars or config folder> \
   org.springframework.boot.loader.PropertiesLauncher

Voir Spring-boot exécutable jar doc et ce lien

Si vous avez MainApps multiples qui est commun, vous pouvez utiliser Comment dire à Spring Boot quelle classe principale utiliser pour l'exécutable jar?

vous pouvez ajouter des emplacements supplémentaires en définissant une variable D'environnement LOADER_PATH ou loader.chemin dans Chargeur.propriétés (liste de répertoires, archives ou répertoires séparés par des virgules dans les archives). Fondamentalement chargeur.le chemin fonctionne à la fois pour java-jar et pour java-cp.

et comme toujours vous pouvez outrepasser et exactement préciser l'application.yml il devrait ramassage fin de débogage

--spring.config.location=/some-location/application.yml --debug

Solution pour le fichier yml:

1.Copier yml dans le même répertoire que jar application

2.Exécuter la commande, par exemple pour xxx.yml :

java -jar app.jar --spring.config.location=xxx.yml

cela fonctionne très bien, mais au démarrage logger est INFO:

No active profile set .........