spring boot loading property file from custom folder

Question

I need to load a property file from src/main/resources/config folder. The loading part is written in a common dependency project where we dont have any control. We are just passing the file name expressed through a dependency. The code snippet in the dependent jar is like below, the standard resource loading.

InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream(propertyFileName);

Spring will always look for recources under recources folder directly, in this case its unable to load the file as its in the custom folder and its not under classpath.

How do we explicitly set the custom folder as additional classpath folder?

With maven we could do something like below which works fine. Is there any OOTB way to achieve this with annotation in spring boot?

    `<resources>
        <resource>
            <directory>src/main/resources</directory>
        </resource>
        <resource>
            <directory>src/main/resources/config</directory>
        </resource>
    </resources>`

Updated

    `// This works if config.properties is directly under resource folder
    // What if config.properties is under resources/config folder.
    // Dont say to pass argument as /config/config.properties, there are some other limitations.
    // So in that case with the same approach, config should come under classpath, so that the below
    // method will work always when the property name is passed.
    // As mentioned earlier, we can use maven resource settings to achieve this.
    // The question here is, is there any way to explicitely advise spring to load property from this folder.
    // I have seen something like loader.path config, not sure that helps!
    InputStream stream = SpringBootStarter.class.getResourceAsStream("/config.properties");`

Answer 1

Before answering, when you say: Spring will always look for recources under recources folder directly, in this case its unable to load the file as its in the custom folder and its not under classpath., this is not correct.

Spring can look anywhere on your system. Here is how you can load different properties file with Spring and Spring boot:

• @PropertySource("classpath:config/common.properties") => Will look under the class path for a file located under the config folder, at the root of your classpath.
• @PropertySource("file:/config/common.properties") => Will look for the file common.properties at the root of your filesystem, here under /config/common.properties.

Now, there is the question of "what is the classpath", it seems like it is worth more explanation.

The classpath is for the JVM what the filesystem is for your OS. When you execute some java code (.jar file for instance), the JVM stores all the files you specify. You can specify files when executing java -classpath /a/shared/folder,/a/dependency/app.jar,myApp.jar MainClass. (See this for some others ways: https://javarevisited.blogspot.com/2012/10/5-ways-to-add-multiple-jar-to-classpath-java.html).
Quite often, what happens for developers (before we use Spring) was this:

1. We develop our application, and use maven for managing the dependencies
2. We execute our app with the IDE, everything works just as fine, life is wonderful
3. We are ready to go live (in production). We generate the famous myApp.jar and try executing the application java -jar myApp.jar and... Nothing works. You have issues with java (I assume you setup the main-class in the Manifest...) and you get something like Caused by: java.lang.ClassNotFoundException: my.dependency.OtherClass...
4. Finally, you realize life is hard and you are not ready to go live right now. You need to have something you can execute easily.

One possible solution to this, to avoid having classpath issues is to put everything in your JAR (called in spring-boot the FAT jar) and you use java -jar myApp.jar and it is working fine.

By default, when you generate a maven project, automatically you have some folders included like:

• src/main/java => your java files and packages
• src/main/resources => your config files (like .properties)
• src/test/java => Your java test files
• src/test/resources => the resources handy for your tests

When you generate your jar (more or less every configuration you added to your maven project, but let's say it is okay), what happens is the compiler takes all the folders and files under src/main/java and src/main/resources and put them at the root of your jar. (Don't hesitate to have a look inside your jar files. This is just a Zip, you can open it, browse it, and see for yourself).

With that said, when you say How do we explicitly set the custom folder as additional classpath folder?, and you talk about a custom folder located under src/main/resources, then when you generate your Jar, the custom folder will be in jar, and therefor, in your classpath.

If you still have troubles, this actions will help you:

• Unzip your jar files and check what is inside. If you don't see any config/ folder in it, maybe your Jar generation is wrong
• Try using @PropertySource(...) to load properties file, in your classpath and in your filesystem, to see how it works and what you achieve
• Have also a look to this:

    <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
    </plugin>

• Don't hesitate to migrate more and more of your old code to Spring-boot, will be a lot easier for you.