What is the best way of reading configuration parameters from configuration file in Java?

I am thinking it will impact performance.

I doubt that this will be true.

Assuming that the application reads the configuration file just once at startup, the time taken to read the file is probably irrelevant to your application's overall performance. Indeed, the longer the application runs, the less important startup time will be.

Standard advice is to only optimize for application performance when you have concrete evidence (i.e. measurements) to say that performance is a significant issue. Then, only optimize those parts of your code that profiling tells you are really a performance bottleneck.

---

Can I use separate final class for configuration details

Yes it is possible to do that. Nobody is going to stop you¹. However, it is a bad idea. Anything that means that you need to recompile your code to change configuration parameters is a bad idea. IMO.

---

To read all configuration details at once from the configuration file and storing them as global constants for later use in application.

Ah ... so you actually want to read the values of the "constants" instead of hard-wiring them.

Yes, that is possible. And it makes more sense than hard-wiring configuration parameters into the code. But it is still not a good idea (IMO).

Why? Well lets look at what the code has to look like:

public final class Config { 
    public static final int CONST_1;
    public static final String CONST_2;
   
    static {
        int c1;
        String c2;
        try (Scanner s = new Scanner(new File("config.txt"))) {
            c1 = s.nextInt();
            c2 = s.next();
        } catch (IOException ex) {
            throw RuntimeException("Cannot load config properties", ex);
        }
        CONST_1 = c1;
        CONST_2 = c2; 
    }
}

First observation is that makes no difference that the class is final. It is declaring the fields as final that makes them constant. (Declaring the class as final prevents subclassing, but that has no impact on the static fields. Static fields are not affected by inheritance.)

Next observation is that this code is fragile in a number of respects:

• If something goes wrong in the static initializer block. the unchecked exception that is thrown by the block will get wrapped as an ExceptionInInitializerError (yes ... it is an Error!!), and the Config class will be marked as erroneous.

• If that happens, there is no realistic hope of recovering, and it possibly even a bad idea to try and diagnose the Error.

• The code above gets executed when the Config class is initialized, but determining when that happens can be tricky.

• If the configuration filename is a parameter, then you have the problem of getting hold of the parameter value ... before the static initialization is triggered.

Next, the code is pretty messy compared with loading the state into a instance variables. And that messiness is largely a result of having to work within the constraints of static initializers. Here's what the code looks like if you use final instance variables instead.

public final class Config { 
    public final int CONST_1;
    public final String CONST_2;
   
    public Config(File file) throws IOException {
        try (Scanner s = new Scanner(file)) {
            CONST_1 = s.nextInt();
            CONST_2 = s.next();
        } 
    }
}

Finally, the performance benefits of static final fields over final fields are tiny:

• probably one or two machine instructions each time you access one of the constants,

• possibly nothing at all if the JIT compiler is smart, and you handle the singleton Config reference appropriately.

In either case, in the vast majority of cases the benefits will be insignificant.

---

^{1 - OK ... if your code is code-reviewed, then someone will probably stop you.}

Have you ever heard of apache commons configuration http://commons.apache.org/proper/commons-configuration/ ? It is the best configuration reader I have ever found and even am using it in my application which is running in production since 1 year. Never found any issues, very easy to understand and use, great performance. I know its a bit of dependency to your application but trust me you will like it.

All you need to do is

Configuration config = new ConfigSelector().getPropertiesConfiguration(configFilePath);
String value = config.getString("key");
int value1 = config.getInt("key1");
String[] value2 = config.getStringArray("key2");
List<Object> value3 = config.getList("key3");

And thats it. Your config object will hold all the config values and you can just pass that object to as many classes as you want. With so many available helpful methods you can extract whichever type of key you want.

It will be only one time cost if you are putting them in a property file and reading the file at the start of your application and initialize all the parameters as system parameters(System.setProperty) and then define constants in your code like

public static final String MY_CONST = System.getProperty("my.const");

But ensure the initialization at start of your application before any other class is loaded.