Java中的Schema校验技术与实践示例详解

flowchart LR
    A[开始] --> B[定义Schema]
    B --> C[应用解析器和校验工具]
    C --> D[数据校验]
    D -->|通过| E[数据处理或使用]
    D -->|失败| F[报告错误信息]

System.setProperty("javax.xml.parsers.DocumentBuilderFactory", "com.sun.org.apache.xerces.internal.jaxp.DocumentBuilderFactoryImpl");

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();

Document document = builder.parse(new File("path/to/xmlfile.xml"));
// 进行Schema校验

SAXParserFactory factory = SAXParserFactory.newInstance();
factory.setSchema(schema); // schema 是预先编译好的 Schema 对象
SAXParser saxParser = factory.newSAXParser();
XMLReader reader = saxParser.getXMLReader();
reader.setContentHandler(new DefaultHandler());
reader.parse(new InputSource(new FileInputStream("path/to/xmlfile.xml")));

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setValidating(true); // 启用校验
DocumentBuilder builder = factory.newDocumentBuilder();
Document document = builder.parse(new File("path/to/xmlfile.xml"));
// Schema校验可能需要额外的配置和处理

SchemaFactory schemaFactory = SchemaFactory.newInstance("http://www.w3.org/2001/XMLSchema");
Schema schema = schemaFactory.newSchema(new File("path/to/schema.xsd"));
Validator validator = schema.newValidator();
Source source = new StreamSource(new File("path/to/xmlfile.xml"));
validator.validate(source); // 执行校验

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           targetNamespace="http://www.example.com/books"
           elementFormDefault="qualified">
    <xs:element name="book">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="title" type="xs:string"/>
                <xs:element name="author" type="xs:string"/>
                <xs:element name="price" type="xs:decimal"/>
            </xs:sequence>
        </xs:complexType>
    </xs:element>
</xs:schema>

xjc -d out -p com.example.books Book.xsd

package com.example.books;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement
public class Book {
    private String title;
    private String author;
    private Double price;
    // Getters and setters...
}

import javax.xml.bind.*;
public class JAXBExample {
    public static void main(String[] args) throws Exception {
        JAXBContext jc = JAXBContext.newInstance(Book.class);
        Marshaller marshaller = jc.createMarshaller();
        marshaller.marshal(new Book("Effective Java", "Joshua Bloch", 42.95), System.out);
        // 输出为: <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
        //        <book>
        //          <title>Effective Java</title>
        //          <author>Joshua Bloch</author>
        //          <price>42.95</price>
        //        </book>
    }
}

import javax.xml.bind.ValidationEvent;
import javax.xml.bind.ValidationEventHandler;
import javax.xml.bind.ValidationException;
import java.io.File;
import javax.xml.XMLConstants;
import javax.xml.transform.stream.StreamSource;
import javax.xml.validation.Schema;
import javax.xml.validation.SchemaFactory;
import javax.xml.validation.Validator;
public class SchemaValidationExample {
    public static void main(String[] args) {
        try {
            SchemaFactory factory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
            Schema schema = factory.newSchema(new StreamSource(new File("path/to/Book.xsd")));
            Validator validator = schema.newValidator();
            validator.setErrorHandler(new ValidationEventHandler() {
                public boolean handleEvent(ValidationEvent event) {
                    System.out.println("Validation error: " + event.getMessage());
                    return true; // Continue validating after handling this event
                }
            });
            // Assume we have a XML file named book.xml that we want to validate
            validator.validate(new StreamSource(new File("path/to/book.xml")));
            System.out.println("XML file is valid.");
        } catch (ValidationException e) {
            System.out.println("Validation error: " + e.getMessage());
        } catch (Exception e) {
            System.out.println("Exception: " + e.getMessage());
        }
    }
}

npm install ajv

const Ajv = require('ajv');
const ajv = new Ajv(); // 创建校验器实例
// 确保使用最新版本的JSON Schema规范
ajv.addMetaSchema(require('ajv/lib/refs/json-schema-draft-06.json'));
// 创建一个简单的schema
const schema = {
  "type": "object",
  "properties": {
    "name": { "type": "string" },
    "age": { "type": "number" }
  },
  "required": ["name", "age"],
  "additionalProperties": false
};
// 编译schema以提高性能
const validate = ajv.compile(schema);
// 待校验的JSON数据
const data = {
  "name": "John",
  "age": 25
};
// 执行校验
const valid = validate(data);
if (!valid) {
  console.error(validate.errors);
} else {
  console.log("No errors!");
}

// 用AJV校验JSON数据
const Ajv = require('ajv');
const ajv = new Ajv();
ajv.addMetaSchema(require('ajv/lib/refs/json-schema-draft-06.json'));
// 定义一个JSON Schema，这里要求有一个字符串类型的"title"和一个对象类型的"author"
const schema = {
  "type": "object",
  "properties": {
    "title": { "type": "string" },
    "author": {
      "type": "object",
      "properties": {
        "name": { "type": "string" },
        "email": { "type": "string" }
      },
      "required": ["name", "email"]
    }
  },
  "required": ["title", "author"]
};
// 编译schema
const validate = ajv.compile(schema);
// 校验数据
const data = {
  "title": "JSON Schema: A Practical Introduction",
  "author": {
    "name": "John Doe",
    "email": "johndoe@example.com"
  }
};
const valid = validate(data);
if (valid) {
  console.log("Data is valid.");
} else {
  console.error("Data is invalid:", validate.errors);
}

import javax.xml.XMLConstants;
import javax.xml.transform.stream.StreamSource;
import javax.xml.validation.Schema;
import javax.xml.validation.SchemaFactory;
import javax.xml.validation.Validator;
import org.xml.sax.ErrorHandler;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
import java.io.File;
import java.io.IOException;
public class XMLSchemaValidator {
    public static void main(String[] args) {
        try {
            // 指定XML和XSD文件的路径
            String xmlFilePath = "example.xml";
            String xsdFilePath = "example.xsd";
            // 创建SchemaFactory实例
            SchemaFactory factory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
            // 从XSD文件加载Schema
            Schema schema = factory.newSchema(new File(xsdFilePath));
            // 创建Validator实例
            Validator validator = schema.newValidator();
            // 设置错误处理器
            validator.setErrorHandler(new ErrorHandler() {
                @Override
                public void warning(SAXParseException exception) throws SAXException {
                    // 处理警告
                    System.err.println("Warning: " + exception.getMessage());
                }
                @Override
                public void error(SAXParseException exception) throws SAXException {
                    // 处理错误
                    System.err.println("Error: " + exception.getMessage());
                }
                @Override
                public void fatalError(SAXParseException exception) throws SAXException {
                    // 处理严重错误
                    System.err.println("Fatal Error: " + exception.getMessage());
                }
            });
            // 校验XML文件
            validator.validate(new StreamSource(new File(xmlFilePath)));
            // 如果没有异常，表示校验成功
            System.out.println("XML is valid.");
        } catch (SAXException e) {
            System.err.println("Schema validation error: " + e.getMessage());
        } catch (IOException e) {
            System.err.println("I/O error: " + e.getMessage());
        }
    }
}

import com.github.fge.jsonschema.SchemaVersion;
import com.github.fge.jsonschema.cfg.ValidationConfiguration;
import com.github.fge.jsonschema.core.exceptions.ProcessingException;
import com.github.fge.jsonschema.core.report.ProcessingReport;
import com.github.fge.jsonschema.main.JsonSchemaFactory;
import com.github.fge.jsonschema.processors.data.FullData;
import com.github.fge.jsonschema.util.JsonLoader;
import java.io.IOException;
public class JSONSchemaValidator {
    public static void main(String[] args) {
        try {
            // 指定JSON和JSON Schema文件的路径
            String jsonFilePath = "example.json";
            String jsonSchemaPath = "example-schema.json";
            // 设置JSON Schema校验库的配置
            ValidationConfiguration configuration = ValidationConfiguration.newBuilder()
                    .withValidationLevel(SchemaVersion.DraftV4.getValidationLevel())
                    .freeze();
            JsonSchemaFactory factory = JsonSchemaFactory.byDefault(configuration);
            // 加载JSON数据和JSON Schema
            FullData data = new FullData(JsonLoader.fromPath(new File(jsonFilePath)));
            JsonSchemaFactory schemaFactory = JsonSchemaFactory.byDefault();
            JsonSchema schema = schemaFactory.getJsonSchema(JsonLoader.fromPath(new File(jsonSchemaPath)));
            // 执行校验
            ProcessingReport report = schema.validate(data);
            // 输出校验结果
            if (report.isSuccess()) {
                System.out.println("JSON is valid.");
            } else {
                report.forEach(message -> System.err.println("Validation error: " + message));
            }
        } catch (IOException | ProcessingException e) {
            System.err.println("Error while validating JSON: " + e.getMessage());
        }
    }
}