Add Document Properties in Word Documents with Java

Posted on by — No Comments ↓

Word documents are more than just text and images; they often contain valuable hidden information known as document properties. These properties, or metadata, play a crucial role in document management, organization, and automation. In a world increasingly reliant on digital content, the ability to programmatically control this metadata is a powerful tool for Java developers.

This tutorial will guide you through the process of adding both built-in and custom document properties to Word files using Java, leveraging the robust capabilities of the Spire.Doc for Java library. By the end, you’ll understand why these properties are essential and how to implement them efficiently in your Java applications.

What is Spire.Doc for Java?

Spire.Doc for Java is a professional Java API designed for creating, writing, editing, converting, and printing Word documents without needing Microsoft Word installed on the server. It supports a wide range of Word document operations, including text manipulation, table processing, image handling, and crucially, managing document properties. Its comprehensive feature set and ease of use make it an excellent choice for automating Word document tasks in Java.

Setting Up Your Project: Adding Spire.Doc for Java

Before we dive into the code, you need to add Spire.Doc for Java to your project. If you’re using Maven, you can easily include the dependency in your pom.xml file. 

<repositories>
    <repository>
        <id>com.e-iceblue</id>
        <name>e-iceblue</name>
        <url>https://repo.e-iceblue.com/nexus/content/groups/public/</url>
    </repository>
</repositories>
<dependencies>
    <dependency>
        <groupId>e-iceblue</groupId>
        <artifactId>spire.doc</artifactId>
        <version>13.12.2</version>
    </dependency>
</dependencies>

Understanding Built-in Document Properties

Built-in document properties are a set of predefined fields that every Word document can have. They provide standard metadata about the document, making it easier to categorize, search, and manage. Examples include:

  • Title: The main title of the document.
  • Author: The creator of the document.
  • Subject: A brief description of the document’s content.
  • Keywords: Important terms for searching.
  • Company: The organization associated with the document.
  • Manager: The manager responsible for the document.
  • Category: The category to which the document belongs.
  • Comments: General remarks or notes about the document.

These properties are incredibly useful for quick identification and filtering of documents within a large repository.

How to Add Built-in Properties with Spire.Doc for Java

Spire.Doc for Java provides straightforward methods to access and modify these built-in properties. Here’s how you can set them: 

import com.spire.doc.BuiltinDocumentProperties;
import com.spire.doc.Document;
import com.spire.doc.FileFormat;

public class AddBuiltinDocumentProperties {
    public static void main(String []args) throws Exception {
        //Create a Document instance
        Document document = new Document();
        //Load a Word document
        document.loadFromFile("Sample.docx");

        //Access the built-in document properties of the document
        BuiltinDocumentProperties standardProperties = document.getBuiltinDocumentProperties();
        //Set the values of specific built-in document properties 
        standardProperties.setTitle("Add Document Properties");
        standardProperties.setSubject("Java Example");
        standardProperties.setAuthor("James");
        standardProperties.setCompany("Eiceblue");
        standardProperties.setManager("Michael");
        standardProperties.setCategory("Document Manipulation");
        standardProperties.setKeywords("Java, Word, Document Properties");
        standardProperties.setComments("This article shows how to add document properties");

        //Save the result document
        document.saveToFile("AddStandardDocumentProperties.docx", FileFormat.Docx_2013);
    }
}

In this example, we create a new Document object, access its BuiltinDocumentProperties using getBuiltinDocumentProperties(), and then use the setter methods (e.g., setTitle(), setAuthor()) to assign values. Finally, the document is saved.

Leveraging Custom Document Properties for Enhanced Metadata

While built-in properties cover common metadata, you often need to store specific information unique to your organization or project. This is where custom document properties come into play. They offer the flexibility to define your own property names and assign various data types (text, numbers, booleans, dates) to them.

Custom properties are invaluable for:

  • Project Management: Storing Project ID, Version Number, Client Name.
  • Document Workflow: Tracking Approval Status, Reviewer, Last Modified By.
  • Internal Classification: Adding Department, Security Level, Retention Policy.
  • Automated Processing: Using properties as triggers for other systems.

Implementing Custom Properties Using Spire.Doc for Java

Adding custom properties with Spire.Doc for Java is as straightforward as built-in ones. You access the CustomDocumentProperties collection and use the add() method. 

import com.spire.doc.CustomDocumentProperties;
import com.spire.doc.Document;
import com.spire.doc.FileFormat;

import java.util.Date;

public class AddCustomDocumentProperties {
    public static void main(String []args) throws Exception {
        //Create a Document instance
        Document document = new Document();
        //Load a Word document
        document.loadFromFile("Sample.docx");

        //Access the custom document properties of the document
        CustomDocumentProperties customProperties = document.getCustomDocumentProperties();
        //Add custom document properties with different data types to the document
        customProperties.add("Document ID", 1);
        customProperties.add("Authorized", true);
        customProperties.add("Authorized By", "John Smith");
        customProperties.add("Authorized Date", new Date());

        //Save the result document
        document.saveToFile("AddCustomDocumentProperties.docx", FileFormat.Docx_2013);
    }
}

In this code:

  1. We initialize a Document object.
  2. We retrieve the CustomDocumentProperties collection using getCustomDocumentProperties().
  3. We use the add() method to create new custom properties, specifying the property name and its value. Spire.Doc handles the underlying data type conversion.

After running these examples, you can open the generated Word documents, go to File > Info > Properties > Advanced Properties, and then navigate to the “Custom” tab to see your added custom properties, and “Summary” or “Statistics” for built-in ones.

Conclusion

Mastering the art of adding document properties in Word files using Java and Spire.Doc for Java is a valuable skill for any developer involved in document automation. We’ve explored how to set both standard built-in properties for general metadata and flexible custom properties for specific, application-driven information.

By embedding this metadata, you significantly enhance the discoverability, organization, and overall utility of your Word documents. This capability is paramount in modern document management systems, enabling powerful search functionalities, automated workflows, and streamlined information retrieval. We encourage you to experiment further with Spire.Doc for Java and explore its vast potential in your Java applications. Happy coding!

Leave a Reply