Validate xml file against xsd schema

Below snippet validated xml file against xsd schema.

public static boolean isXmlValid(String xmlFilePath, String schemaFilePath) {

 if (xmlFilePath == null || xmlFilePath.isEmpty()) {
  throw new IllegalArgumentException("xmlFilePath is empty");
 }

 if (schemaFilePath == null || schemaFilePath.isEmpty()) {
  throw new IllegalArgumentException("schemaFilePath is empty");
 }

 File schemaFile = new File(schemaFilePath);
 Source xmlFile = new StreamSource(new File(xmlFilePath));
 SchemaFactory schemaFactory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
 try {
  Schema schema = schemaFactory.newSchema(schemaFile);
  Validator validator = schema.newValidator();
  validator.validate(xmlFile);
  return true;
 } catch (Exception e) {
  return false;
 }
}

If your xsd comes from some url use below snippet.

public static boolean isXmlValid(String xmlFilePath, URL schemaFilePath) {

 if (xmlFilePath == null || xmlFilePath.isEmpty()) {
  throw new IllegalArgumentException("xmlFilePath is empty");
 }

 if (schemaFilePath == null) {
  throw new IllegalArgumentException("schemaFilePath is empty");
 }

 Source xmlFile = new StreamSource(new File(xmlFilePath));
 SchemaFactory schemaFactory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
 try {
  Schema schema = schemaFactory.newSchema(schemaFilePath);
  Validator validator = schema.newValidator();
  validator.validate(xmlFile);
  return true;
 } catch (Exception e) {
  return false;
 }
}

Find the below working application.

employee.xsd

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

 <!-- Schema for simple elements -->
        <xs:element name="id" type="xs:integer" />
 <xs:element name="firstname" type="xs:string" />
 <xs:element name="middlename" type="xs:string" />
 <xs:element name="lastname" type="xs:string" />
 <xs:element name="age" type="xs:integer" />
        <xs:element name="salary" type="xs:decimal" />
        <xs:element name="married" type="xs:string" />
        <xs:element name="department" type="xs:string" />
        <xs:element name="pjtname" type="xs:string" />
 <xs:element name="from" type="xs:date" />
 <xs:element name="to " type="xs:date" />
        
 <!-- Schema for element name -->
 <xs:element name="name">
  <xs:complexType>
   <xs:sequence>
                            <xs:element ref="firstname" />
                            <xs:element ref="middlename" />
                            <xs:element ref="lastname" />
                            <xs:element ref="age" />
                            <xs:element ref="salary" />
                            <xs:element ref="married" />
   </xs:sequence>
  </xs:complexType>
 </xs:element>

         <!-- Schema for element project -->
 <xs:element name="project">
  <xs:complexType>
   <xs:sequence>
                            <xs:element ref="department" />
                            <xs:element ref="pjtname" />
                            <xs:element ref="from" />
                            <xs:element ref="to" />
   </xs:sequence>
  </xs:complexType>
 </xs:element>

         <!-- Schema for element employee -->
 <xs:element name="employee">
  <xs:complexType>
   <xs:sequence>
                            <xs:element ref="id" />
                            <xs:element ref="name" />
                            <xs:element ref="project" maxOccurs="unbounded" />
   </xs:sequence>
  </xs:complexType>
 </xs:element>

          <!-- Schema for element employees -->
 <xs:element name="employees">
  <xs:complexType>
   <xs:sequence>
                            <xs:element ref="employee" maxOccurs="unbounded" />
   </xs:sequence>
  </xs:complexType>
 </xs:element>
 
</xs:schema>

employee.xml

<?xml version="1.0" encoding="UTF-8"?>
   
<employees xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:noNamespaceSchemaLocation="employees.xsd">

    <employee>
        <id>1</id>
        <name>
            <firstname>Hari</firstname>
            <middlename>Krishna</middlename>
            <lastname>Gurram</lastname>
            <age>25</age>
            <salary>80000</salary>
            <married>single</married>
        </name>

        <project>
            <department>aero</department>
            <pjtname>Flight Controls</pjtname>
            <from>2011-09-16</from>
            <to>2013-01-22</to>
        </project>

        <project>
            <department>banking</department>
            <pjtname>Online Transaction Processing System</pjtname>
            <from>2013-01-23</from>
            <to>2014-10-06</to>
        </project>

        <project>
            <department>mobile</department>
            <pjtname>Daily News Application</pjtname>
            <from>2014-10-07</from>
            <to>2015-05-06</to>
        </project>
    </employee>
</employees>

App.java

package com.sample.app;

import java.io.File;
import java.net.URL;

import javax.xml.XMLConstants;
import javax.xml.transform.Source;
import javax.xml.transform.stream.StreamSource;
import javax.xml.validation.Schema;
import javax.xml.validation.SchemaFactory;
import javax.xml.validation.Validator;

public class App {

    public static boolean isXmlValid(String xmlFilePath, String schemaFilePath) {

        if (xmlFilePath == null || xmlFilePath.isEmpty()) {
            throw new IllegalArgumentException("xmlFilePath is empty");
        }

        if (schemaFilePath == null || schemaFilePath.isEmpty()) {
            throw new IllegalArgumentException("schemaFilePath is empty");
        }

        File schemaFile = new File(schemaFilePath);
        Source xmlFile = new StreamSource(new File(xmlFilePath));
        SchemaFactory schemaFactory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
        try {
            Schema schema = schemaFactory.newSchema(schemaFile);
            Validator validator = schema.newValidator();
            validator.validate(xmlFile);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    public static boolean isXmlValid(String xmlFilePath, URL schemaFilePath) {

        if (xmlFilePath == null || xmlFilePath.isEmpty()) {
            throw new IllegalArgumentException("xmlFilePath is empty");
        }

        if (schemaFilePath == null) {
            throw new IllegalArgumentException("schemaFilePath is empty");
        }

        Source xmlFile = new StreamSource(new File(xmlFilePath));
        SchemaFactory schemaFactory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
        try {
            Schema schema = schemaFactory.newSchema(schemaFilePath);
            Validator validator = schema.newValidator();
            validator.validate(xmlFile);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    public static void main(String args[]) {
        String xmlFilePath = "/Users/Shared/xml/employee.xml";
        String schemaFilePath = "/Users/Shared/xml/employee.xsd";

        boolean valid = isXmlValid(xmlFilePath, schemaFilePath);

        if (valid) {
            System.out.println("xml is valid");
        } else {
            System.out.println("xml is invalid");
        }

    }

}

You may like

Miscellaneous

Interview Questions

Programming Questions

Print float value without scientific notation

Print double value without scientific notation

How to create a jar file

Java: Get content hash of the file

AES Symmetric encryption example