Convert XML to Properties

Why Convert XML to Java Properties?

Converting XML files to Java Properties format simplifies complex hierarchical configuration into clean, flat key-value pairs that Java applications consume natively. XML configuration files like Spring's applicationContext.xml, Maven's settings.xml, and various enterprise configurations can be flattened into the .properties format that is simpler to read, edit, and manage in modern Java and Spring Boot applications.

This conversion is especially important for teams migrating from legacy XML-based configuration to modern Spring Boot applications that prefer application.properties or application.yml. Instead of manually rewriting configurations, you can convert XML directly to properties format, preserving all settings as dot-notation keys (e.g., spring.datasource.url, server.port).

Our converter flattens XML hierarchy into dot-separated property keys: nested elements like <database><host>localhost</host></database> become database.host=localhost. Attributes are included with appropriate key suffixes, repeated elements use indexed notation (items.0, items.1), and comments are generated to document the original XML structure.

Java Properties files are the simplest configuration format in the Java ecosystem. They require no special parser (java.util.Properties is built into every JVM), produce clean one-line-per-setting diffs in version control, and integrate seamlessly with Spring's @Value annotation and @ConfigurationProperties binding. The flat structure makes it immediately clear what each setting does.

Key Benefits of Converting XML to Java Properties:

• Simplified Configuration: Replace verbose XML tags with clean key=value pairs
• Spring Boot Ready: Output works directly as application.properties
• Native Java Support: Read with java.util.Properties without any library
• Easy Editing: Simple text format editable in any editor
• Version Control Friendly: One setting per line produces clean Git diffs
• Migration Path: Move from legacy XML config to modern properties-based setup
• Environment Override: Properties can be easily overridden via environment variables

Practical Examples

Example 1: Spring Database Configuration

Input XML file (applicationContext.xml):

<beans>
  <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource">
    <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
    <property name="username" value="admin"/>
    <property name="password" value="secret"/>
  </bean>
</beans>

Output Properties file (application.properties):

# DataSource Configuration
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=admin
spring.datasource.password=secret

Example 2: Log4j Logging Configuration

Input XML file (log4j2.xml):

<Configuration status="WARN">
  <Appenders>
    <Console name="Console" target="SYSTEM_OUT">
      <PatternLayout pattern="%d{HH:mm:ss} [%t] %-5level %logger - %msg%n"/>
    </Console>
  </Appenders>
  <Loggers>
    <Root level="info">
      <AppenderRef ref="Console"/>
    </Root>
  </Loggers>
</Configuration>

Output Properties file (log4j.properties):

# Logging Configuration
configuration.status=WARN
appender.console.type=Console
appender.console.name=Console
appender.console.target=SYSTEM_OUT
appender.console.layout.type=PatternLayout
appender.console.layout.pattern=%d{HH:mm:ss} [%t] %-5level %logger - %msg%n
rootLogger.level=info
rootLogger.appenderRef.console.ref=Console

Example 3: Maven Settings

Input XML file (settings.xml):

<settings>
  <localRepository>/home/user/.m2/repository</localRepository>
  <servers>
    <server>
      <id>nexus-releases</id>
      <username>deployer</username>
      <password>deploy123</password>
    </server>
    <server>
      <id>nexus-snapshots</id>
      <username>deployer</username>
      <password>deploy123</password>
    </server>
  </servers>
</settings>

Output Properties file (settings.properties):

# Maven Settings
settings.localRepository=/home/user/.m2/repository
settings.servers.0.id=nexus-releases
settings.servers.0.username=deployer
settings.servers.0.password=deploy123
settings.servers.1.id=nexus-snapshots
settings.servers.1.username=deployer
settings.servers.1.password=deploy123

Frequently Asked Questions (FAQ)

Q: What is XML format?

A: XML (Extensible Markup Language) is a W3C standard for structuring, storing, and transporting data. It uses custom tags with a strict hierarchical tree structure. XML is used in enterprise integration (SOAP), configuration files (Maven pom.xml, Spring, Android), document formats (XHTML, SVG, DOCX internals), financial data (XBRL), and healthcare (HL7). Unlike HTML, XML tags are self-describing and user-defined.

Q: What is a Java Properties file?

A: A Java Properties file (.properties) is a simple key-value configuration format used throughout the Java ecosystem. Each line contains a key=value pair, with # for comments. Java provides native support via the java.util.Properties class. Properties files are the standard configuration format for Spring Boot (application.properties), logging (log4j.properties), internationalization (messages.properties), and build tools (gradle.properties).

Q: How is XML hierarchy flattened to key-value pairs?

A: The converter uses dot-notation to flatten XML hierarchy. Nested elements become dot-separated keys: <database><host>localhost</host></database> becomes database.host=localhost. Attributes are appended to the key path, and repeated elements use numeric indices (items.0, items.1). This convention is compatible with Spring Boot's property binding.

Q: Can I use the output directly in Spring Boot?

A: Yes, the generated properties file uses dot-notation that Spring Boot understands natively. You can use it as application.properties or application-{profile}.properties. Spring's @Value("${key}") and @ConfigurationProperties annotations can directly bind to the generated keys. You may need to adjust some key names to match Spring Boot conventions.

Q: What happens to XML attributes during conversion?

A: XML attributes are included in the property keys. For example, <server id="main" port="8080"/> might produce server.id=main and server.port=8080. The attribute name becomes part of the dot-notation key, preserving all configuration data in the flat format.

Q: How are repeated XML elements handled?

A: Repeated elements at the same level are indexed numerically. For example, multiple <server> elements become servers.0.host=..., servers.1.host=..., and so on. This indexed notation is compatible with Spring Boot's list binding using @ConfigurationProperties.

Q: Should I use Properties or YAML for Spring Boot?

A: Both are fully supported by Spring Boot. Properties files are simpler, have native Java support, and produce cleaner Git diffs (one change per line). YAML supports nested structure and is more compact for complex configurations. For XML migration, properties is often the easier first step, as both XML and properties are flat when compared to YAML's indentation-based nesting.

Q: Can I convert large XML configuration files?

A: Yes, our converter handles XML files of any reasonable size. Complex configurations with deep nesting produce longer property keys but remain valid and readable. The output includes comment separators to organize related properties into logical groups based on the original XML structure.