Config File In Java: Explained

Config or configuration refers to setting up or specifying the settings, options, or parameters a system, application, or tool needs to operate correctly. A config determines how a system behaves, what resources it uses, and how it interacts with its environment.

A configuration file allows users or developers to adjust a program’s behavior without altering its source code. These files are particularly important for application flexibility, reusability, and scalability.

What is a Config File in Java?

The config file contains plain texts containing key-value pairs representing settings and configurations. It has the extension of .properties, .xml, .yaml, .json and is generally stored in the application’s root directory.

Configuration files store essential details like database connection strings, external service URLs, and other settings required by the framework. They enable developers to write adaptable code that interacts with these settings seamlessly, eliminating the need for hardcoding values.

Importance of Configuration Files in Java Applications

A configuration file in Java allows developers to separate configurable parameters from the source code, making applications more flexible, maintainable, and adaptable to different environments (e.g., development, testing, production).

It is an external source for application settings, enabling easier updates without modifying and recompiling the Java application. Configuration files are also essential for storing sensitive data like passwords and API keys. By placing this information in a separate file, developers can prevent it from being exposed in the source code.

This helps protect the application’s security and the data it contains. Additionally, config files can store application settings, such as the default language or the window size. This allows developers to customize the application for different users easily.

Types of Configuration Files in Java

There are four different ways to store the configuration details in Java.

Properties file

It has a format of key value pairs. You can store simple configurations like database URLs, credentials, and application settings.

Example:

# Database Configuration

db.url=jdbc:mysql://localhost:3306/mydb

db.username=root

db.password=mypassword

XML file

This is structured data in hierarchy form. It helps in complex configurations, such as Spring Framework configurations or logging settings.

Example:

<configuration>

<database>

     <url>jdbc:mysql://localhost:3306/mydb</url>

     <username>root</username>

     <password>password</password>

</database>

</configuration>

YAML file

It is a human-readable format with indentation for hierarchy. It is mostly used in Spring Boot applications and Docker configurations.

Example:

db:

  url: jdbc:mysql://localhost:3306/mydb

  username: root

  password: password

JSON file

It has the format of key-value pairs, which will be defined inside the set bracket. This format helps store configurations for RESTful APIs, web services, or modern Java applications.

Example:

{

  "database": {

"url": "jdbc:mysql://localhost:3306/mydb",

"username": "root",

"password": "mypassword"

  }

}

How to create a Config File in Java

• Creating the config file is as easy as creating a new file.
• Before creating it, make sure to decide the type of config file which you want to use.
• Next step is to create a new file and start adding the required values into it.
• After adding all of the necessary key-value pairs, save the file and use it to store your application’s configuration settings.
• Use the Config File to store user preferences, such as the preferred language or color scheme.
• This makes it easy to customize your application for each user.

How to store data in a config File in Java

• The data storage method in the config file differs based on the extension we would like to store.
• For properties file, it will have the format as key and value with equal to symbol in between the assignments,

Example:

# Database Configuration

db.url=jdbc:mysql://localhost:3306/mydb

db.username=root

db.password=mypassword

XML stands for Extensible Markup Language. The XML file will have structured data in hierarchy form.

Example:

<configuration>

<database>

     <url>jdbc:mysql://localhost:3306/mydb</url>

     <username>root</username>

     <password>password</password>

</database>

</configuration>

YAML stands for YAML Ain’t Markup Language. It is a plain text file that stores data in a human-readable format.

Example:

db:

  url: jdbc:mysql://localhost:3306/mydb

  username: root

  password: password

JSON stands for JavaScript Object Notation. JSON is built from one or more keys and values, where keys can be any string and values can be strings, numbers, arrays, additional objects, or the literals false, true, and null.

Example:

{

  "database": {

"url": "jdbc:mysql://localhost:3306/mydb",

"username": "root",

"password": "mypassword"

  }

}

Steps to Modify a Config File in Java

Modifying a configuration file in Java is a straightforward process. Follow these steps for efficient and safe editing:

1. Open the Config File: Use any text editor or IDE to access the configuration file.
2. Locate the Value to be Changed: Search for the specific key or value you wish to modify within the file.
3. Make the Changes: Edit the desired value, ensuring it aligns with the required format or acceptable parameters outlined in the documentation.
4. Save the Changes: Save the file and restart your application for the changes to take effect.
5. Backup the Original File: Always keep a copy of the original configuration file as a backup to revert changes if issues arise.
6. Refer to Documentation: Review the file’s documentation to ensure modifications are valid and won’t cause errors.

How to read a Config File in Java

Here is how to read a Config file in Java:

• Properties config file: You should first create a file named config.properties and save it with below values,

db.url=jdbc:mysql://localhost:3306/mydb

db.username=root

db.password=secret

app.name=MyApplication

The next step is to read the data from the properties file and try to extract it.

import java.io.FileInputStream;

import java.io.IOException;

import java.util.Properties;

public class ConfigReader {

public static void main(String[] args) {

     Properties properties = new Properties();

     try (FileInputStream fis = new FileInputStream("config.properties")) {

         // Load the properties file

         properties.load(fis);

         // Access properties using keys

         String dbUrl = properties.getProperty("db.url");

         String dbUsername = properties.getProperty("db.username");

         String dbPassword = properties.getProperty("db.password");

         String appName = properties.getProperty("app.name");

         // Print the values

         System.out.println("Database URL: " + dbUrl);

         System.out.println("Username: " + dbUsername);

         System.out.println("Password: " + dbPassword);

         System.out.println("Application Name: " + appName);

     } catch (IOException e) {

         e.printStackTrace();

     }

}

}

When you execute the above file named ConfigReader.java, you can print the values inside the config files.

• XML config file: First step is to store the below config file with the name as config.xml,

<?xml version="1.0" encoding="UTF-8"?>

<configuration>

<database>

     <url>jdbc:mysql://localhost:3306/mydb</url>

     <username>root</username>

     <password>secret</password>

</database>

</configuration>

Next step is to read and access the configuration values with the help of below code,

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;



public class ConfigReader {

public static void main(String[] args) {

     try {

         // Load and parse the XML file

         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

         DocumentBuilder builder = factory.newDocumentBuilder();

         Document document = builder.parse("config.xml");



         // Normalize the XML structure

         document.getDocumentElement().normalize();



         // Read database configuration

         NodeList dbList = document.getElementsByTagName("database");

         Node dbNode = dbList.item(0); // Assuming only one database element

         if (dbNode.getNodeType() == Node.ELEMENT_NODE) {

             Element dbElement = (Element) dbNode;

             String dbUrl = dbElement.getElementsByTagName("url").item(0).getTextContent();

             String dbUsername = dbElement.getElementsByTagName("username").item(0).getTextContent();

             String dbPassword = dbElement.getElementsByTagName("password").item(0).getTextContent();



             System.out.println("Database URL: " + dbUrl);

             System.out.println("Username: " + dbUsername);

             System.out.println("Password: " + dbPassword);

         }

     } catch (Exception e) {

         e.printStackTrace();

     }

}

}

When you execute the above code, you can get the required config details in the output.

• YAML file: This file extension should be .yaml file.

Save the below file as config.yaml,

database:

  url: jdbc:mysql://localhost:3306/mydb

  username: root

  password: secret

Next step is to create a java file to read the configs,

import java.io.BufferedReader;

import java.io.FileReader;

import java.io.IOException;

import java.util.HashMap;

import java.util.Map;



public class ConfigReader {



public static void main(String[] args) {

     String yamlFile = "config.yaml";

     Map<String, Map<String, String>> config = new HashMap<>();



     try (BufferedReader reader = new BufferedReader(new FileReader(yamlFile))) {

         String line;

         String currentSection = null;



         while ((line = reader.readLine()) != null) {

             line = line.trim(); // Remove leading and trailing whitespace



             // Skip empty lines or comments

             if (line.isEmpty() || line.startsWith("#")) {

                 continue;

             }



             if (line.endsWith(":") && !line.startsWith(" ")) {

                 // It's a section (e.g., "database:")

                 currentSection = line.substring(0, line.length() - 1).trim();

                 config.put(currentSection, new HashMap<>());

             } else if (currentSection != null && line.contains(":")) {

                 // It's a key-value pair (e.g., "url: jdbc:mysql://localhost:3306/mydb")

                 String[] parts = line.split(":", 2);

                 String key = parts[0].trim();

                 String value = parts[1].trim();

                 config.get(currentSection).put(key, value);

             }

         }



         // Access the parsed data

         Map<String, String> database = config.get("database");



         System.out.println("Database URL: " + database.get("url"));

         System.out.println("Username: " + database.get("username"));

         System.out.println("Password: " + database.get("password"));



     } catch (IOException e) {

         e.printStackTrace();

     }

}

}

• JSON config file: You can save the below file as json config file,

{

  "database": {

"url": "jdbc:mysql://localhost:3306/mydb",

"username": "root",

"password": "secret"

  }

}

Next step is to read the json config file from Java file,

import javax.json.*;

import java.io.FileReader;

import java.io.IOException;



public class ConfigReader {



public static void main(String[] args) {

     try (FileReader reader = new FileReader("config.json")) {

         JsonReader jsonReader = Json.createReader(reader);

         JsonObject jsonObject = jsonReader.readObject();

         jsonReader.close();



         // Access nested objects

         JsonObject database = jsonObject.getJsonObject("database");

         String dbUrl = database.getString("url");

         String dbUsername = database.getString("username");

         String dbPassword = database.getString("password");



         // Print values

         System.out.println("Database URL: " + dbUrl);

         System.out.println("Username: " + dbUsername);

         System.out.println("Password: " + dbPassword);



     } catch (IOException e) {

         e.printStackTrace();

     }

}

}

After executing the above file, you should be able to see the details that you have kept inside the config.json file.

Common Challenges with Java Config Files

Working with Java configuration files, such as .properties, .yaml, .xml, or .json files, is a common practice in application development, especially for handling environment-specific settings, application parameters, and database connections.

However, developers encounter several challenges when using Java config files.

• Varied File Formats: Applications and services often require different formats such as .properties, .yaml, .xml, or .json. While Java’s Properties class supports .properties files, it does not natively support .yaml or .json, necessitating additional libraries.
• Manual Type Conversion: Configuration files store values as strings (e.g., URLs, passwords), requiring manual conversion to appropriate types like integers or booleans. Java’s Properties class lacks automatic type conversion, making the process prone to errors.
• Environment-Specific Configurations: Managing separate configurations for environments like development, staging, and production can be challenging. Ensuring the correct file is used in each scenario adds complexity.
• Overriding Configurations: Overriding values for specific scenarios (e.g., testing or production) can become cumbersome, particularly when managing multiple profiles or environments.
• Lack of Validation: Config files can contain missing, incorrect, or unexpected values. Java’s Properties class does not offer built-in validation, increasing the risk of runtime errors from misconfigured files.
• Complexity in Large Applications: As applications scale, configuration files often grow large and complex. Managing numerous properties, especially across shared and environment-specific settings, becomes increasingly difficult.

Best practices for using Java Configuration Files

Below are some best practices for using Config files in Java:

• To overcome file incompatibility, use external libraries (like Jackson for JSON, SnakeYAML for YAML, or Java’s built-in javax.xml for XML).
• You may need to write custom code to convert property values into their correct types or use libraries that automatically map configuration values to Java objects, like Jackson for JSON or SnakeYAML for YAML.
• Use environment variables or profiles to load the correct config file dynamically. Spring’s @Profile annotations, for instance, can load different property files based on the environment. Alternatively, use external tools like Apache Commons Configuration or Spring Boot’s application configuration profiles.
• Ensure that config files are loaded in a thread-safe manner, or consider caching the properties in memory. Some frameworks like Spring Boot offer ways to load configurations in a thread-safe manner.
• Implement validation logic to check for required properties. For example, use a ConfigValidator class to check for missing or invalid properties during application startup.
• Split large configuration files into smaller, more manageable ones (e.g., separate config files for database, application, security, etc.), and load only the necessary configurations based on context. A framework like Spring can also help manage and organize configurations more effectively.
• Encrypt sensitive data before saving it in configuration files, or store secrets in secure vaults (e.g., HashiCorp Vault) or external services. Additionally, tools like Spring Cloud Config Server offer secure configuration management.

Testing on Real Devices with BrowserStack

BrowserStack offers a real device cloud platform where you can access over 3500+ different devices, browsers, and OS combinations. This powerful cloud-based testing platform is designed to streamline and enhance the testing processes.

Automate helps reduce testing times by enabling parallel test execution, and it facilitates testing of internally hosted apps seamlessly, providing confidence in the user experience of applications.

Talk to an Expert

Conclusion

While configuration files are a simple and convenient way to manage application settings, they come with various challenges related to format handling, validation, security, and environment management.

By following best practices, using appropriate libraries, and leveraging tools like Spring Boot, developers can effectively address these challenges and create more robust, maintainable, and secure configuration management systems.