Java: Read or Remove Properties from Word Documents
Document properties are some important information contained in Word documents, including title, subject, author, company, keywords, etc. Reading this information can help identify the document, quickly determine the document type or source, and improve the efficiency of document storage and organization. However, if the document properties such as author and company are inappropriate for others to know, you can remove them to protect privacy. This article is going to show how to read or remove document properties in Word documents programmatically using Spire.Doc for Java.
- Read Built-in and Custom Properties from Word Documents
- Remove Built-in and Custom Properties from Word Documents
Install Spire.Doc for Java
First, you're required to add the Spire.Doc.jar file as a dependency in your Java program. The JAR file can be downloaded from this link. If you use Maven, you can easily import the JAR file in your application by adding the following code to your project's 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.6.2</version>
</dependency>
</dependencies>
Read Built-in and Custom Properties from Word Documents
There are two types of properties in Word documents: built-in properties and custom properties. Built-in properties are some predefined properties, while custom properties are properties with custom names, types, and values. The detailed steps for reading the two kinds of document properties are as follows:
- Create an object of Document.
- Load a Word document using Document.loadFromFile() method.
- Get all the built-in properties and custom properties using Document.getBuiltinDocumentProperties() method and Document.getCustomDocumentProperties() method.
- Get each built-in property using methods under BuiltinDocumentProperties class.
- Loop through the custom properties to get their name and value using methods under CustomDocumentProperties class.
- Java
import com.spire.doc.BuiltinDocumentProperties;
import com.spire.doc.CustomDocumentProperties;
import com.spire.doc.Document;
public class GetDocumentProperties {
public static void main(String[] args) {
//Create an object of Document
Document document = new Document();
//Load a Word document
document.loadFromFile("C:/Sample.docx");
//Create an object of StringBuilder
StringBuilder properties = new StringBuilder();
//Get all the built-in properties and custom properties
BuiltinDocumentProperties builtinDocumentProperties = document.getBuiltinDocumentProperties();
CustomDocumentProperties customDocumentProperties = document.getCustomDocumentProperties();
//Get each built-in property
String title = builtinDocumentProperties.getTitle();
String subject = builtinDocumentProperties.getSubject();
String author = builtinDocumentProperties.getAuthor();
String manager = builtinDocumentProperties.getManager();
String category = builtinDocumentProperties.getCategory();
String company = builtinDocumentProperties.getCompany();
String keywords = builtinDocumentProperties.getKeywords();
String comments = builtinDocumentProperties.getComments();
//Set string format for displaying
String builtinProperties = String.format("The built-in properties:\r\nTitle: " + title
+ "\r\nSubject: " + subject + "\r\nAuthor: " + author
+ "\r\nManager: " + manager + "\r\nCategory: " + category
+ "\r\nCompany: " + company + "\r\nKeywords: "+ keywords
+ "\r\nComments:" + comments
);
//Add the built-in properties to the StringBuilder object
properties.append(builtinProperties);
//Get each custom property
properties.append("\r\n\r\nThe custom properties:");
for (int i = 0; i < customDocumentProperties.getCount(); i++) {
String customProperties = String.format("\r\n" + customDocumentProperties.get(i).getName() + ": " + document.getCustomDocumentProperties().get(i).getValue());
//Add the custom properties to the StringBuilder object
properties.append(customProperties);
}
//Output the properties of the document
System.out.println(properties);
}
}
Remove Built-in and Custom Properties from Word Documents
Built-in document properties can be removed by setting their values as empty. For custom document properties, we can use the CustomDocumentProperties.get().getName() method to get their name and then use CustomDocumentProperties.remove() method to remove them. The detailed steps are as follows:
- Create an object of Document.
- Load a Word document using Document.loadFromFile() method.
- Get all built-in properties and custom properties using Document.getBuiltinDocumentProperties() method and Document.getCustomDocumentProperties() method.
- Remove the built-in properties by setting their values as empty using methods under BuiltinDocumentProperties class.
- Get the count of custom properties using CustomDocumentProperties.getCount() method.
- Loop through the custom properties, get their names by using CustomDocumentProperties.get().getName() method, and remove each custom property by their name using CustomDocumentProperties.remove() method.
- Save the document using Document.saveToFile() method.
- Java
import com.spire.doc.BuiltinDocumentProperties;
import com.spire.doc.CustomDocumentProperties;
import com.spire.doc.Document;
import com.spire.doc.FileFormat;
public class RemoveDocumentProperties {
public static void main(String[] args) {
//Create an object of Document
Document document = new Document();
//Load a Word document
document.loadFromFile("C:/Sample.docx");
//Get all built-in properties and custom properties
BuiltinDocumentProperties builtinDocumentProperties = document.getBuiltinDocumentProperties();
CustomDocumentProperties customDocumentProperties = document.getCustomDocumentProperties();
//Remove built-in properties by setting their value to empty
builtinDocumentProperties.setTitle("");
builtinDocumentProperties.setSubject("");
builtinDocumentProperties.setAuthor("");
builtinDocumentProperties.setManager("");
builtinDocumentProperties.setCompany("");
builtinDocumentProperties.setCategory("");
builtinDocumentProperties.setKeywords("");
builtinDocumentProperties.setComments("");
//Get the count of custom properties
int count = customDocumentProperties.getCount();
//Loop through the custom properties to remove them
for (int i = count; i > 0; i-- ){
//Get the name of a custom property
String name = customDocumentProperties.get(i-1).getName();
//Remove the custom property by its name
customDocumentProperties.remove(name);
}
//Save the document
document.saveToFile("RemoveDocumentProperties.docx", FileFormat.Auto);
document.dispose();
}
}
Apply for a Temporary License
If you'd like to remove the evaluation message from the generated documents, or to get rid of the function limitations, please request a 30-day trial license for yourself.
Java: Create a Fillable Form in Word
Word allows you to create forms that other people can use to enter information. Fillable forms are used for a variety of purposes. Human resources use forms to collect employee and consultant information. Marketing departments use forms to survey customer satisfaction with their products and services. Organizations use forms to register members, students, or clients. Some of the tools you will use when creating a form include:
- Content Controls: The areas where users input information in a form.
- Tables: Tables are used in forms to align text and form fields, and to create borders and boxes.
- Protection: Allows users to populate fields but not to make changes to the rest of the document.
Content controls in Word are containers for content that let users build structured documents. A structured document controls where content appears within the document. There are basically ten types of content controls available in Word 2013. This article focuses on how to create a fillable form in Word consisting of the following seven common content controls using Spire.Doc for Java.
| Content Control | Description |
| Plain Text | A text field limited to plain text, so no formatting can be included. |
| Rich Text | A text field that can contain formatted text or other items, such as tables, pictures, or other content controls. |
| Picture | Accepts a single picture. |
| Drop-Down List | A drop-down list displays a predefined list of items for the user to choose from. |
| Combo Box | A combo box enables users to select a predefined value in a list or type their own value in the text box of the control. |
| Check Box | A check box provides a graphical widget that allows the user to make a binary choice: yes (checked) or no (not checked). |
| Date Picker | Contains a calendar control from which the user can select a date. |
Install Spire.Doc for Java
First of all, you're required to add the Spire.Doc.jar file as a dependency in your Java program. The JAR file can be downloaded from this link. If you use Maven, you can easily import the JAR file in your application by adding the following code to your project's 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.6.2</version>
</dependency>
</dependencies>
Create a Fillable Form in Word in Java
The StructureDocumentTagInline class provided by Spire.Doc for Java is used to create structured document tags for inline-level structures (DrawingML object, fields, etc.) in a paragraph. The SDTProperties property and the SDTContent property under this class shall be used to specify the properties and content of the current structured document tag. The following are the detailed steps to create a fillable form with content controls in Word.
- Create a Document object.
- Add a section using Document.addSection() method.
- Add a table using Section.addTable() method.
- Add a paragraph to a specific table cell using TableCell.addParagraph() method.
- Create an instance of StructureDocumentTagInline class, and add it to the paragraph as a child object using Paragraph.getChildObjects().add() method.
- Specify the properties and content of the structured document tag using the methods under the SDTProperties property and the SDTContent property of the StructureDocumentTagInline object. The type of the structured document tag is set through SDTProperties.setSDTType() method.
- Prevent users from editing content outside form fields using Document.protect() method.
- Save the document using Document.saveToFile() method.
- Java
import com.spire.doc.*;
import com.spire.doc.documents.*;
import com.spire.doc.fields.DocPicture;
import com.spire.doc.fields.TextRange;
import java.util.Date;
public class CreateFillableForm {
public static void main(String[] args) {
//Create a Document object
Document doc = new Document();
//Add a section
Section section = doc.addSection();
//add a table
Table table = section.addTable(true);
table.resetCells(7, 2);
//Add text to the cells of the first column
Paragraph paragraph = table.getRows().get(0).getCells().get(0).addParagraph();
paragraph.appendText("Plain Text Content Control");
paragraph = table.getRows().get(1).getCells().get(0).addParagraph();
paragraph.appendText("Rich Text Content Control");
paragraph = table.getRows().get(2).getCells().get(0).addParagraph();
paragraph.appendText("Picture Content Control");
paragraph = table.getRows().get(3).getCells().get(0).addParagraph();
paragraph.appendText("Drop-Down List Content Control");
paragraph = table.getRows().get(4).getCells().get(0).addParagraph();
paragraph.appendText("Check Box Content Control");
paragraph = table.getRows().get(5).getCells().get(0).addParagraph();
paragraph.appendText("Combo box Content Control");
paragraph = table.getRows().get(6).getCells().get(0).addParagraph();
paragraph.appendText("Date Picker Content Control");
//Add a plain text content control to the cell (0,1)
paragraph = table.getRows().get(0).getCells().get(1).addParagraph();
StructureDocumentTagInline sdt = new StructureDocumentTagInline(doc);
paragraph.getChildObjects().add(sdt);
sdt.getSDTProperties().setSDTType(SdtType.Text);
sdt.getSDTProperties().setAlias("Plain Text");
sdt.getSDTProperties().setTag("Plain Text");
sdt.getSDTProperties().isShowingPlaceHolder(true);
SdtText text = new SdtText(true);
text.isMultiline(false);
sdt.getSDTProperties().setControlProperties(text);
TextRange tr = new TextRange(doc);
tr.setText("Click or tap here to enter text.");
sdt.getSDTContent().getChildObjects().add(tr);
//Add a rich text content control to the cell (1,1)
paragraph = table.getRows().get(1).getCells().get(1).addParagraph();
sdt = new StructureDocumentTagInline(doc);
paragraph.getChildObjects().add(sdt);
sdt.getSDTProperties().setSDTType(SdtType.Rich_Text);
sdt.getSDTProperties().setAlias("Rich Text");
sdt.getSDTProperties().setTag("Rich Text");
sdt.getSDTProperties().isShowingPlaceHolder(true);
text = new SdtText(true);
text.isMultiline(false);
sdt.getSDTProperties().setControlProperties(text);
tr = new TextRange(doc);
tr.setText("Click or tap here to enter text.");
sdt.getSDTContent().getChildObjects().add(tr);
//Add a picture content control to the cell (2,1)
paragraph = table.getRows().get(2).getCells().get(1).addParagraph();
sdt = new StructureDocumentTagInline(doc);
paragraph.getChildObjects().add(sdt);
sdt.getSDTProperties().setSDTType(SdtType.Picture);
sdt.getSDTProperties().setAlias("Picture");
sdt.getSDTProperties().setTag("Picture");
SdtPicture sdtPicture = new SdtPicture();
sdt.getSDTProperties().setControlProperties(sdtPicture);
DocPicture pic = new DocPicture(doc);
pic.loadImage("C:\\Users\\Administrator\\Desktop\\ChooseImage.png");
sdt.getSDTContent().getChildObjects().add(pic);
//Add a dropdown list content control to the cell(3,1)
paragraph = table.getRows().get(3).getCells().get(1).addParagraph();
sdt = new StructureDocumentTagInline(doc);
sdt.getSDTProperties().setSDTType(SdtType.Drop_Down_List);
sdt.getSDTProperties().setAlias("Dropdown List");
sdt.getSDTProperties().setTag("Dropdown List");
paragraph.getChildObjects().add(sdt);
SdtDropDownList sddl = new SdtDropDownList();
sddl.getListItems().add(new SdtListItem("Choose an item.", "1"));
sddl.getListItems().add(new SdtListItem("Item 2", "2"));
sddl.getListItems().add(new SdtListItem("Item 3", "3"));
sddl.getListItems().add(new SdtListItem("Item 4", "4"));
sdt.getSDTProperties().setControlProperties(sddl);
tr = new TextRange(doc);
tr.setText(sddl.getListItems().get(0).getDisplayText());
sdt.getSDTContent().getChildObjects().add(tr);
//Add two check box content controls to the cell (4,1)
paragraph = table.getRows().get(4).getCells().get(1).addParagraph();
sdt = new StructureDocumentTagInline(doc);
paragraph.getChildObjects().add(sdt);
sdt.getSDTProperties().setSDTType(SdtType.Check_Box);
SdtCheckBox scb = new SdtCheckBox();
sdt.getSDTProperties().setControlProperties(scb);
tr = new TextRange(doc);
sdt.getChildObjects().add(tr);
scb.setChecked(false);
paragraph.appendText(" Option 1");
paragraph = table.getRows().get(4).getCells().get(1).addParagraph();
sdt = new StructureDocumentTagInline(doc);
paragraph.getChildObjects().add(sdt);
sdt.getSDTProperties().setSDTType(SdtType.Check_Box);
scb = new SdtCheckBox();
sdt.getSDTProperties().setControlProperties(scb);
tr = new TextRange(doc);
sdt.getChildObjects().add(tr);
scb.setChecked(false);
paragraph.appendText(" Option 2");
//Add a combo box content control to the cell (5,1)
paragraph = table.getRows().get(5).getCells().get(1).addParagraph();
sdt = new StructureDocumentTagInline(doc);
paragraph.getChildObjects().add(sdt);
sdt.getSDTProperties().setSDTType(SdtType.Combo_Box);
sdt.getSDTProperties().setAlias("Combo Box");
sdt.getSDTProperties().setTag("Combo Box");
SdtComboBox cb = new SdtComboBox();
cb.getListItems().add(new SdtListItem("Choose an item."));
cb.getListItems().add(new SdtListItem("Item 2"));
cb.getListItems().add(new SdtListItem("Item 3"));
sdt.getSDTProperties().setControlProperties(cb);
tr = new TextRange(doc);
tr.setText(cb.getListItems().get(0).getDisplayText());
sdt.getSDTContent().getChildObjects().add(tr);
//Add a date picker content control to the cell (6,1)
paragraph = table.getRows().get(6).getCells().get(1).addParagraph();
sdt = new StructureDocumentTagInline(doc);
paragraph.getChildObjects().add(sdt);
sdt.getSDTProperties().setSDTType(SdtType.Date_Picker);
sdt.getSDTProperties().setAlias("Date Picker");
sdt.getSDTProperties().setTag("Date Picker");
SdtDate date = new SdtDate();
date.setCalendarType(CalendarType.Default);
date.setDateFormat("yyyy.MM.dd");
date.setFullDate(new Date());
sdt.getSDTProperties().setControlProperties(date);
tr = new TextRange(doc);
tr.setText("Click or tap to enter a date.");
sdt.getSDTContent().getChildObjects().add(tr);
//Allow users to edit the form fields only
doc.protect(ProtectionType.Allow_Only_Form_Fields, "permission-psd");
//Save to file
doc.saveToFile("output/WordForm.docx", FileFormat.Docx_2013);
}
}
Apply for a Temporary License
If you'd like to remove the evaluation message from the generated documents, or to get rid of the function limitations, please request a 30-day trial license for yourself.
Java: Add Document Properties to Word Documents
The properties of a document are a set of information about the document and its content, such as title, subject, author's name, manager, company, category, keywords (also known as tags), and comments. This information does not appear in the content of the document, but it can help you better search, sort, and filter files. In this article, you will learn how to add document properties to Word documents in Java using Spire.Doc for Java.
- Add Built-in Document Properties to a Word Document
- Add Custom Document Properties to a Word Document
Install Spire.Doc for Java
First, you're required to add the Spire.Doc.jar file as a dependency in your Java program. The JAR file can be downloaded from this link. If you use Maven, you can easily import the JAR file in your application by adding the following code to your project's 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.6.2</version>
</dependency>
</dependencies>
Add Built-in Document Properties to a Word Document in Java
A built-in document property (also known as a standard document property) consists of a name and a value. You cannot set or change the name of a built-in document property as it’s predefined by Microsoft Word, but you can set or change its value. The following steps demonstrate how to set values for built-in document properties in a Word document in Java using Spire.Doc for Java:
- Initialize an instance of Document class.
- Load a Word document using Document.loadFromFile() method.
- Access the built-in document properties of the document using Document.getBuiltinDocumentProperties() method.
- Set the values of specific document properties such as title, subject and author using setTitle(), setSubject() and setAuthor() methods provided by BuiltinDocumentProperties class.
- Save the result document using Document.saveToFile() method.
- Java
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);
}
}
Add Custom Document Properties to a Word Document in Java
A custom document property can be defined by a document author or user. Each custom document property should contain a name, a value and a data type. The data type can be one of these four types: Text, Date, Number and Yes or No. The following steps demonstrate how to add custom document properties with different data types to a Word document in Java using Spire.Doc for Java:
- Initialize an instance of Document class.
- Load a Word document using Document.loadFromFile() method.
- Access the custom document properties of the document using Document.getCustomDocumentProperties() method.
- Add custom document properties with different data types to the document using CustomDocumentProperties.add(String, Object) method.
- Save the result document using Document.saveToFile() method.
- Java
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);
}
}
Apply for a Temporary License
If you'd like to remove the evaluation message from the generated documents, or to get rid of the function limitations, please request a 30-day trial license for yourself.
Java: Merge Word Documents
Sometimes we need to merge several related Word documents to make a more complete one. To merge documents with MS Word, you need to manually copy and paste contents or import contents from other documents, which can be tedious. Luckily, Spire.Doc for Java provides 2 easy ways to merge Word documents by programming. This article will show the detailed steps to merge Word documents.
Install Spire.Doc for Java
First, you're required to add the Spire.Doc.jar file as a dependency in your Java program. The JAR file can be downloaded from this link. If you use Maven, you can easily import the JAR file in your application by adding the following code to your project's 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.6.2</version>
</dependency>
</dependencies>
Merge Documents by Inserting the Entire File
The method Document.insertTextFromFile() provided by Spire.Doc allows merging Word documents by inserting other documents entirely into a document with the inserted contents starting from a new page.
The detailed steps of merging documents by inserting the entire file are as follows:
- Create an object of Document class and load a Word document from disk.
- Insert another Word document entirely to the loaded document using Document.insertTextFromFile() method.
- Save the result document using Document.saveToFile() method.
- Java
import com.spire.doc.*;
public class merge {
public static void main(String[] args) {
//Create an object of Document and load a Word document from disk
Document document = new Document("C:/Samples/Sample1.docx");
//Insert another Word document entirely to the document
document.insertTextFromFile("C:/Samples/Sample2.docx", FileFormat.Docx_2013);
//Save the result document
document.saveToFile("MergingResult.docx", FileFormat.Docx_2013);
}
}
Merge Documents by Cloning Contents
If you want to merge documents without starting a new page, you can clone the contents of other documents to add to the end of a document.
The detailed steps of merging documents by cloning contents are as follows:
- Create two objects of Document and load the two Word documents from disk.
- Loop through the second document to get all the sections using Document.getSections() method, then loop through all the sections to get their child objects using Section.getBod().getChildObjects() method, then get the last section of the first document using Document.getLastSection() method, and then add the child objects to the last section of the first document using Body.getChildObjects().add() method.
- Save the result document using Document.saveToFile() method.
- Java
import com.spire.doc.*;
public class mergeDocuments {
public static void main(String[] args){
//Create two Document objects and load two Word documents from disk
Document document1 = new Document("C:/Samples/Sample1.docx");
Document document2 = new Document("C:/Samples/Sample2.docx");
//Loop through the second document to get all the sections
for (Object sectionObj : (Iterable) document2.getSections()) {
Section sec=(Section)sectionObj;
//Loop through the sections of the second document to get their child objects
for (Object docObj :(Iterable ) sec.getBody().getChildObjects()) {
DocumentObject obj=(DocumentObject)docObj;
//Get the last section of the first document
Section lastSection = document1.getLastSection();
//Add the child objects to the last section of the first document
Body body = lastSection.getBody();
body.getChildObjects().add(obj.deepClone());
}
}
//Save the result document
document1.saveToFile("MergingResult.docx", FileFormat.Docx_2013);
}
}
Apply for a Temporary License
If you'd like to remove the evaluation message from the generated documents, or to get rid of the function limitations, please request a 30-day trial license for yourself.
Java: Print Word Documents
Printing Word documents is a fundamental aspect of document management, allowing you to transform digital files into tangible, physical copies. Whether you need to produce hard copies for reference, distribution, or archival purposes, the ability to print Word documents is a valuable skill that remains relevant in various professional and personal settings.
In this article, you will learn how to print Word documents in Java using the Spire.Doc for Java library and java.awt.print package.
- Print Word with the Default Printer in Java
- Print Word with a Specified Printer in Java
- Print Word with a Print Dialog Box in Java
- Print a Range of Pages in Word in Java
- Print Word in Duplex Mode in Java
Install Spire.Doc for Java
First, you're required to add the Spire.Doc.jar file as a dependency in your Java program. The JAR file can be downloaded from this link. If you use Maven, you can easily import the JAR file in your application by adding the following code to your project's 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.6.2</version>
</dependency>
</dependencies>
Print Word with the Default Printer in Java
Printing Word documents with the default printer is a convenient and straightforward method. This approach is often suitable for regular printing tasks when specific printer settings are not necessary or when users prefer to utilize the default configurations set in their printer.
The following are the steps to print Word documents with the default printer using Spire.Doc for Java and java.awt.print.
- Create a PrinterJob object, and call the methods under it to set up a print job.
- Create a Document object, and load a Word document using Document.LoadFromFile() method.
- Render each page of the document in the specified format using PrinterJob.setPrintable() method.
- Call PrinterJob.print() method to print the Word document.
- Java
import com.spire.doc.Document;
import java.awt.print.PageFormat;
import java.awt.print.Paper;
import java.awt.print.PrinterException;
import java.awt.print.PrinterJob;
public class PrintWithDefaultPrinter {
public static void main(String[] args) {
// Create a Document object
Document document = new Document();
// Load a Word file
document.loadFromFile("C:\\Users\\Administrator\\Desktop\\Input.docx");
// Create a PrinterJob object
PrinterJob printerJob = PrinterJob.getPrinterJob();
// Create a PageFormat object and set it to the default size and orientation
PageFormat pageFormat = printerJob.defaultPage();
// Return a copy of the Paper object associated with this PageFormat
Paper paper = pageFormat.getPaper();
// Set the imageable area of this Paper
paper.setImageableArea(0, 0, pageFormat.getWidth(), pageFormat.getHeight());
// Set the number of copies to be printed
printerJob.setCopies(1);
// Set the Paper object for this PageFormat
pageFormat.setPaper(paper);
// Call painter to render the pages in the specified format
printerJob.setPrintable(document, pageFormat);
// Print document
try {
printerJob.print();
} catch (PrinterException e) {
e.printStackTrace();
}
}
}
Print Word with a Specified Printer in Java
Printing a Word document with a specified printer in Java allows you to choose a specific printer device to handle the printing task. This approach can be useful in scenarios where you have multiple printers available and want to direct the print output to a specific one.
The following are the steps to print Word documents with a specified printer using Spire.Doc for Java and java.awt.print.
- Create a PrinterJob object, and call the methods under it to set up a print job.
- Find the print service by the printer name using the custom method findPrintService().
- Apply the print service using PrinterJob.setPrintService() method.
- Create a Document object, and load a Word document using Document.LoadFromFile() method.
- Render each page of the document in the specified format using PrinterJob.setPrintable() method.
- Call PrinterJob.print() method to print the Word document.
- Java
import com.spire.doc.Document;
import javax.print.PrintService;
import java.awt.print.PageFormat;
import java.awt.print.Paper;
import java.awt.print.PrinterException;
import java.awt.print.PrinterJob;
public class PrintWithSpecifiedPrinter {
public static void main(String[] args) throws PrinterException {
// Create a PrinterJob object which is initially associated with the default printer
PrinterJob printerJob = PrinterJob.getPrinterJob();
// Specify printer name
PrintService myPrintService = findPrintService("\\\\192.168.1.104\\HP LaserJet P1007");
printerJob.setPrintService(myPrintService);
// Create a PageFormat instance and set it to a default size and orientation
PageFormat pageFormat = printerJob.defaultPage();
// Return a copy of the Paper object associated with this PageFormat.
Paper paper = pageFormat.getPaper();
// Set the imageable area of this Paper.
paper.setImageableArea(0, 0, pageFormat.getWidth(), pageFormat.getHeight());
// Set the Paper object for this PageFormat.
pageFormat.setPaper(paper);
// Create a Document object
Document document = new Document();
// Load a Word file
document.loadFromFile("C:\\Users\\Administrator\\Desktop\\Input.docx");
// Call painter to render the pages in the specified format
printerJob.setPrintable(document, pageFormat);
// Print document
try {
printerJob.print();
} catch (PrinterException e) {
e.printStackTrace();
}
}
// Find print service
private static PrintService findPrintService(String printerName) {
PrintService[] printServices = PrinterJob.lookupPrintServices();
for (PrintService printService : printServices) {
if (printService.getName().equals(printerName)) {
return printService;
}
}
return null;
}
}
Print Word with a Print Dialog Box in Java
Printing a Word document with a print dialog box enables users to select a printer and customize print settings before initiating the process. By presenting a print dialog box, you provide users with flexibility and control over the printing operation.
To print Word document with a print dialog box in Java, follow these step:
- Create a PrinterJob object, and call methods under it to set up a print job.
- Create a Document object, and load a Word document using Document.LoadFromFile() method.
- Render each page of the document in the specified format using PrinterJob.setPrintable() method.
- Call PrinterJob.printDialog() method to display print dialog.
- Call PrinterJob.print() method to print the Word document.
- Java
import com.spire.doc.Document;
import java.awt.print.PageFormat;
import java.awt.print.Paper;
import java.awt.print.PrinterException;
import java.awt.print.PrinterJob;
public class PrintWithDialogBox {
public static void main(String[] args) {
// Create a PrinterJob object which is initially associated with the default printer
PrinterJob printerJob = PrinterJob.getPrinterJob();
// Create a PageFormat object and set it to a default size and orientation
PageFormat pageFormat = printerJob.defaultPage();
// Return a copy of the Paper object associated with this PageFormat
Paper paper = pageFormat.getPaper();
// Set the imageable area of this Paper
paper.setImageableArea(0, 0, pageFormat.getWidth(), pageFormat.getHeight());
// Set the Paper object for this PageFormat
pageFormat.setPaper(paper);
// Create a Document object
Document document = new Document();
// Load a Word file
document.loadFromFile("C:\\Users\\Administrator\\Desktop\\Math.docx");
// Call painter to render the pages in the specified format
printerJob.setPrintable(document, pageFormat);
// Display the print dialog
if (printerJob.printDialog()) {
try {
// Print document
printerJob.print();
} catch (PrinterException e) {
e.printStackTrace();
}
}
}
}
Print a Range of Pages in Word in Java
Printing a range of pages in Microsoft Word is a useful feature that allows you to select specific pages from a document and print only those pages, rather than printing the entire document. This can be particularly handy when you're working with lengthy documents or when you only need to print a specific section.
The steps to set print range while printing Word documents in Java are as follows.
- Create a PrinterJob object, and call the methods under it to set up a print job.
- Create a Document object, and load a Word document using Document.LoadFromFile() method.
- Render each page of the document in the specified format using PrinterJob.setPrintable() method.
- Create a PrintRequestAttributeSet object, and add the print range to the attribute set.
- Call PrinterJob.print() method to print the range of pages.
- Java
import com.spire.doc.Document;
import javax.print.attribute.HashPrintRequestAttributeSet;
import javax.print.attribute.PrintRequestAttributeSet;
import javax.print.attribute.standard.PageRanges;
import java.awt.print.PageFormat;
import java.awt.print.Paper;
import java.awt.print.PrinterException;
import java.awt.print.PrinterJob;
public class PrintPageRange {
public static void main(String[] args) {
// Create a Document object
Document document = new Document();
// Load a Word file
document.loadFromFile("C:\\Users\\Administrator\\Desktop\\Input.docx");
// Create a PrinterJob object
PrinterJob printerJob = PrinterJob.getPrinterJob();
// Create a PageFormat object and set it to the default size and orientation
PageFormat pageFormat = printerJob.defaultPage();
// Return a copy of the Paper object associated with this PageFormat
Paper paper = pageFormat.getPaper();
// Set the imageable area of this Paper
paper.setImageableArea(0, 0, pageFormat.getWidth(), pageFormat.getHeight());
// Set the number of copies
printerJob.setCopies(1);
// Set the Paper object for this PageFormat
pageFormat.setPaper(paper);
// Call painter to render the pages in the specified format
printerJob.setPrintable(document, pageFormat);
// Create a PrintRequestAttributeSet object
PrintRequestAttributeSet attributeSet = new HashPrintRequestAttributeSet();
// Set print range
attributeSet.add(new PageRanges(1,5));
// Print document
try {
printerJob.print(attributeSet);
} catch (PrinterException e) {
e.printStackTrace();
}
}
}
Print Word in Duplex Mode in Java
Duplex printing, also known as two-sided printing, allows you to print on both sides of a sheet of paper automatically, which can be beneficial for lengthy reports, presentations, or handouts.
The steps to print Word documents in duplex mode in Java are as follows.
- Create a PrinterJob object, and call the methods under it to set up a print job.
- Create a Document object, and load a Word document using Document.LoadFromFile() method.
- Render each page of the document in the specified format using PrinterJob.setPrintable() method.
- Create a PrintRequestAttributeSet object, and add the two-sided printing mode to the attribute set.
- Call PrinterJob.print() method to print the Word document.
- Java
import com.spire.doc.Document;
import javax.print.attribute.HashPrintRequestAttributeSet;
import javax.print.attribute.PrintRequestAttributeSet;
import javax.print.attribute.standard.Sides;
import java.awt.print.PageFormat;
import java.awt.print.Paper;
import java.awt.print.PrinterException;
import java.awt.print.PrinterJob;
public class PrintInDuplexMode {
public static void main(String[] args) {
// Create a Document object
Document document = new Document();
// Load a Word file
document.loadFromFile("C:\\Users\\Administrator\\Desktop\\Input.docx");
// Create a PrinterJob object which is initially associated with the default printer
PrinterJob printerJob = PrinterJob.getPrinterJob();
// Create a PageFormat object and set it to a default size and orientation
PageFormat pageFormat = printerJob.defaultPage();
// Return a copy of the Paper object associated with this PageFormat
Paper paper = pageFormat.getPaper();
// Set the imageable area of this Paper
paper.setImageableArea(0, 0, pageFormat.getWidth(), pageFormat.getHeight());
// Set the Paper object for this PageFormat
pageFormat.setPaper(paper);
// Call painter to render the pages in the specified format
printerJob.setPrintable(document, pageFormat);
// Create a PrintRequestAttributed object
PrintRequestAttributeSet attributeSet = new HashPrintRequestAttributeSet();
// Enable duplex printing mode
attributeSet.add(Sides.TWO_SIDED_SHORT_EDGE);
// Print document
try {
printerJob.print(attributeSet);
} catch (PrinterException e) {
e.printStackTrace();
}
}
}
Apply for a Temporary License
If you'd like to remove the evaluation message from the generated documents, or to get rid of the function limitations, please request a 30-day trial license for yourself.
Java: Create a Word Document from Scratch
Creating Word documents programmatically in Java enables developers to automate report generation, invoice creation, and other document workflows with precision. With Spire.Doc for Java, you can dynamically build, format, and customize Word files directly from your applications-without relying on Microsoft Office.
This article guides you through the essential steps to generate a Word document from scratch, covering text formatting, image insertion, table creation, and list management. Whether you're producing business reports, contracts, or data-driven documents, this tutorial provides the foundation to streamline your document automation process in Java.
- Add Titles, Headings, and Paragraphs to a Word Document
- Add an Image to a Word Document
- Add a Table to a Word Document
- Add a List to a Word Document
Install Spire.Doc for Java
First of all, you're required to add the Spire.Doc.jar file as a dependency in your Java program. The JAR file can be downloaded from this link. If you use Maven, you can easily import the JAR file in your application by adding the following code to your project's 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.6.2</version>
</dependency>
</dependencies>
Add Titles, Headings, and Paragraphs to a Word Document in Java
When creating structured Word documents with Spire.Doc for .NET, its core functionality revolves around the Document and Section classes. Use the addParagraph() method to add new paragraphs and the appendText() method to insert text content. To ensure consistent formatting, you can apply built-in styles (such as Title or Heading 1-4), which achieve professional and standardized typesetting effects. You can also customize styles to precisely control fonts, colors, and sizes, thereby creating personalized document designs.
The steps to add titles, headings, and paragraphs to a Word document in Java are as follows:
- Create a Document object.
- Use Document.addSection() to add sections to the document.
- Use Section.addParagraph() to add paragraphs to a section.
- Apply built-in styles (Title, Heading1, Heading2, Heading3) to specific paragraphs using Paragraph.applyStyle().
- Define a custom paragraph style using ParagraphStyle() and apply it to the specified paragraph.
- Save the document as a DOCX file.
- Java
import com.spire.doc.*;
import com.spire.doc.documents.*;
import com.spire.doc.fields.*;
import java.awt.Color;
public class CreateSimpleDocument {
public static void main(String[] args) {
// Create a Document object
Document document = new Document();
// Add a section
Section section = document.addSection();
// Set page margins
section.getPageSetup().getMargins().setAll(60f);
// Add a title paragraph
Paragraph title_para = section.addParagraph();
TextRange textRange = title_para.appendText("This Is Title");
title_para.applyStyle(BuiltinStyle.Title);
textRange.getCharacterFormat().setFontName("Times New Roman");
// Add a couple of heading paragraphs
Paragraph heading_one = section.addParagraph();
textRange = heading_one.appendText("Heading 1");
heading_one.applyStyle(BuiltinStyle.Heading_1);
textRange.getCharacterFormat().setFontName("Times New Roman");
Paragraph heading_two = section.addParagraph();
textRange = heading_two.appendText("Heading 2");
heading_two.applyStyle(BuiltinStyle.Heading_2);
textRange.getCharacterFormat().setFontName("Times New Roman");
Paragraph heading_three = section.addParagraph();
textRange = heading_three.appendText("Heading 3");
heading_three.applyStyle(BuiltinStyle.Heading_3);
textRange.getCharacterFormat().setFontName("Times New Roman");
Paragraph heading_four = section.addParagraph();
textRange = heading_four.appendText("Heading 4");
heading_four.applyStyle(BuiltinStyle.Heading_4);
textRange.getCharacterFormat().setFontName("Times New Roman");
// Add a normal paragraph
Paragraph normal_para = section.addParagraph();
normal_para.appendText("This is a sample paragraph.");
// Create a paragraph style
ParagraphStyle style = new ParagraphStyle(document);
style.setName("paraStyle");
style.getCharacterFormat().setFontName("Times New Roman");
style.getCharacterFormat().setFontSize(13f);
style.getCharacterFormat().setTextColor(Color.blue);
document.getStyles().add(style);
// Apply the custom style to the paragraph
normal_para.applyStyle("paraStyle");
// Save the document
document.saveToFile("output/AddText.docx", FileFormat.Docx);
// Dispose resources
document.dispose();
}
}
Add an Image to a Word Document in Java
To insert an image into a Word document, you first need to create a dedicated paragraph element as the image container. By using the appendPicture() method, you can load an image from the file system and embed it directly into the document structure.
The steps to add an image to a Word document in Java are as follows:
- Create a Document object.
- Use Document.addSection() to add a section to the document.
- Add a paragraph to the section using Section.addParagraph().
- Insert the image into the paragraph using Paragraph.appendPicture().
- Save the document as a DOCX file.
- Java
import com.spire.doc.*;
import com.spire.doc.documents.*;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
public class AddImage {
public static void main(String[] args) throws IOException {
// Create a Document object
Document document = new Document();
// Add a section
Section section = document.addSection();
// Set page margins
section.getPageSetup().getMargins().setAll(60f);
// Add a paragraph
Paragraph image_para = section.addParagraph();
// Load an image file
BufferedImage image = ImageIO.read(new File("C:\\Users\\Administrator\\Desktop\\logo.png"));
// Append it to the paragraph
image_para.appendPicture(image);
// Save the document
document.saveToFile("output/AddImage.docx", FileFormat.Docx);
// Dispose resources
document.dispose();
}
}
Add a Table to a Word Document in Java
The table creation process begins with the addTable() method, which is used to establish the basic table structure. Using the resetCells() method, you can specify the desired number of rows and columns. Once initialized, filling each cell with content requires first adding a paragraph element via the addParagraph() method, followed by inserting text using the appendText() method.
The steps to add a table to a Word document in Java are as follows:
- Create a Document object.
- Use Document.addSection() to add a section to the document.
- Create a two-dimensional array to store table data (including headers and values).
- Generate the table using Section.addTable().
- Call the Table.resetCells() method to define the number of rows and columns based on the data.
- Iterate through the data array and use the TableCell.addParagraph() and Paragraph.appendText() methods to add text to each cell.
- Save the document as a DOCX file.
- Java
import com.spire.doc.*;
import com.spire.doc.documents.*;
import com.spire.doc.fields.*;
public class AddTable {
public static void main(String[] args) {
// Create a Document object
Document document = new Document();
// Add a section
Section section = document.addSection();
// Set page margins
section.getPageSetup().getMargins().setAll(60f);
// Define table data as a 2D array
String[][] data = {
{"Product", "Unit Price", "Quantity", "Sub Total"},
{"A", "$29", "120", "$3,480"},
{"B", "$35", "110", "$3,850"},
{"C", "$68", "140", "$9,520"}
};
// Add a table
Table table = section.addTable(true);
// Set row number and column number
table.resetCells(data.length, data[0].length);
// Write data to cells
for (int r = 0; r < data.length; r++) {
TableRow row = table.getRows().get(r);
row.setHeight(20);
row.setHeightType(TableRowHeightType.Exactly);
for (int c = 0; c < data[r].length; c++) {
TableCell cell = row.getCells().get(c);
cell.getCellFormat().setVerticalAlignment(VerticalAlignment.Middle);
TextRange textRange = cell.addParagraph().appendText(data[r][c]);
textRange.getCharacterFormat().setFontName("Times New Roman");
textRange.getCharacterFormat().setFontSize(14);
}
}
// Automatically adjusts the column widths of a table to fit its contents
table.autoFit(AutoFitBehaviorType.Auto_Fit_To_Contents);
// Save the document to file
document.saveToFile("output/AddTable.docx", FileFormat.Docx);
// Dispose resources
document.dispose();
}
}
Add a List to a Word Document in Java
The ListStyle class provides the foundation for implementing bulleted lists and numbered lists in documents. By configuring this class, you can establish a unified visual format for all list items. Once the list style is defined, simply apply it to target paragraphs using the applyStyle() method.
The steps to add a list to a Word document in Java are as follows:
- Create a Document object.
- Use Document.addSection() to add a section to the document.
- Define the list style using ListStyle().
- Add paragraphs to the section using Section.addParagraph().
- Apply the defined list style to paragraphs using Paragraph.getListFormat().applyStyle().
- Save the document as a DOCX file.
- Java
import com.spire.doc.*;
import com.spire.doc.documents.*;
import com.spire.doc.fields.*;
public class AddList {
public static void main(String[] args) {
// Create a Document object
Document document = new Document();
// Add a section
Section section = document.addSection();
// Set page margins
section.getPageSetup().getMargins().setAll(60f);
// Create a bulleted list style
ListStyle listStyle = new ListStyle(document, ListType.Bulleted);
listStyle.setName("bulletedList");
listStyle.getLevels().get(0).setBulletCharacter("\u00B7");
listStyle.getLevels().get(0).getCharacterFormat().setFontName("Symbol");
listStyle.getLevels().get(0).setTextPosition(20);
document.getListStyles().add(listStyle);
// Add a paragraph
Paragraph paragraph = section.addParagraph();
TextRange textRange = paragraph.appendText("Fruits:");
paragraph.getFormat().setAfterSpacing(5f);
textRange.getCharacterFormat().setFontName("Times New Roman");
textRange.getCharacterFormat().setFontSize(14);
// Add another four paragraphs as bulleted list items
String[] fruits = {"Apple", "Banana", "Watermelon", "Mango"};
for (String fruit : fruits) {
paragraph = section.addParagraph();
textRange = paragraph.appendText(fruit);
paragraph.getListFormat().applyStyle(listStyle.getName());
paragraph.getListFormat().setListLevelNumber(0);
textRange.getCharacterFormat().setFontName("Times New Roman");
textRange.getCharacterFormat().setFontSize(14);
}
// Save the document to file
document.saveToFile("output/AddList.docx", FileFormat.Docx);
// Dispose resources
document.dispose();
}
}
This tutorial provides a brief introduction to the basic operations of creating Word documents using Spire.Doc for Java, including core functionalities such as inserting titles, paragraphs, images, tables, and lists. For more comprehensive element additions and finer formatting settings, please refer to the official Spire.Doc online tutorials for complete guidance.
Get a Free License
To fully experience the capabilities of Spire.Doc for Java without any evaluation limitations, you can request a free 30-day trial license.