在oracle中验证xml文档'；s的java源代码

试着做这个题目

我正在尝试从文件（schemasource=1）和clob（schemasource=0）使用xsd。 我有两个xsd模式：common_types.xsd和migom.xsd。二包括一。 问题是，当我从文件中使用公共_类型模式时，我得到了一个错误

ORA-29532:未捕获的Java异常终止了Java调用：oracle.xml.parser.v2.XMLParseException:发生内部错误情况

当我仅根据从clob读取的第一个模式验证xml时，我获得了成功，但当我添加第二个xsd时，我得到了相同的错误，这说明什么也没有

create or replace and compile java source named XmlTools AS
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.XMLReader;

import org.xml.sax.InputSource;
import oracle.sql.CLOB;
import java.io.IOException;
import org.xml.sax.SAXException;
import java.sql.SQLException;
import java.lang.IllegalArgumentException;
import oracle.xml.parser.v2.XMLParseException;
import javax.xml.parsers.ParserConfigurationException;

import java.io.*;

public class XmlValidator
{

  static final String JAXP_SCHEMA_LANGUAGE = "http://java.sun.com/xml/jaxp/properties/schemaLanguage";
  static final String W3C_XML_SCHEMA = "http://www.w3.org/2001/XMLSchema"; 
  static final String JAXP_SCHEMA_SOURCE = "http://java.sun.com/xml/jaxp/properties/schemaSource";


  public static void ValidateDocument(int schemasource, oracle.sql.CLOB schemadoc, oracle.sql.CLOB schemadoc1, oracle.sql.CLOB xmldoc) throws SAXException, IOException, SQLException, ParserConfigurationException, XMLParseException, IllegalArgumentException {


    try
          {              

            File myfile = new File(".//XML//common_types.xsd");
            if (myfile.exists())
            {
                Serv.log("ValidateDocument", "file size" + Long.toString(myfile.length()));
            }
            /*else
            {
                Serv.log("ValidateDocument", "file doesn't exists" );
            }*/

            Serv.log("ValidateDocument", "1" );
            SAXParserFactory factory = SAXParserFactory.newInstance();
            factory.setValidating(true);
            factory.setNamespaceAware(true);

            Serv.log("ValidateDocument", "2" );        
            SAXParser saxParser = factory.newSAXParser();
            saxParser.setProperty(JAXP_SCHEMA_LANGUAGE, W3C_XML_SCHEMA);

            if (schemasource == 0)
            {
                InputSource schemaIs = new InputSource(schemadoc.getCharacterStream());        
                InputSource schemaIs1 = new InputSource(schemadoc1.getCharacterStream());  

                InputSource[] schemas = {schemaIs, schemaIs1};

                //saxParser.setProperty(JAXP_SCHEMA_SOURCE,   schemaIs); 
                saxParser.setProperty(JAXP_SCHEMA_SOURCE,   schemas); 
            }
            else
            {            
                saxParser.setProperty(JAXP_SCHEMA_SOURCE,   ".//XML//common_types.xsd"); 
            }
            XMLReader reader = saxParser.getXMLReader();

            //Получаем входной XML документ
            InputSource documentIs = new InputSource(xmldoc.getCharacterStream());
            Serv.log("ValidateDocument", "3" );          
            //Запуск разбора
            reader.parse(documentIs);
            Serv.log("ValidateDocument", "4" );          
            documentIs = null;     

           }
    /*catch (SAXException e) 
    {
        Serv.log("ValidateDocument", "SAXException" );
        Serv.log("ValidateDocument", "document is not valid because ");
        Serv.log("ValidateDocument", e.getMessage());
        throw(e);
    }*/          
    catch (ParserConfigurationException e) 
    {
        Serv.log("ValidateDocument", "ParserConfigurationException" );
        throw(e);
    }
    catch (IOException e) 
    {
        Serv.log("ValidateDocument", "IOException" );        
        throw(e);
    }

    catch (XMLParseException e)
    {
        Serv.log("ValidateDocument", "XMLParseException" );        
        Serv.log("ValidateDocument", e.getMessage());
        StackTraceElement[] stack = e.getStackTrace();        
        for (int i = 0; i < stack.length; i++)
        {
         Serv.log("stacktrace element no " + Integer.toString(i), "toString: " + stack[i].toString());
         Serv.log("stacktrace element no " + Integer.toString(i), "file name: " + stack[i].getFileName() + ", class name: " + stack[i].getClassName() + ", method name: " + stack[i].getMethodName() + ", line : " + stack[i].getLineNumber());
        }

        throw(e);
    }
    catch (IllegalArgumentException e)
    {
        Serv.log("ValidateDocument", "IllegalArgumentException" );        
        Serv.log("ValidateDocument", e.getMessage());
        throw(e);    
    }           


    }

}

创建或替换并编译名为XmlTools的java源代码
导入javax.xml.parsers.parserConfiguration异常；
导入javax.xml.parsers.SAXParser；
导入javax.xml.parsers.SAXParserFactory；
导入org.xml.sax.XMLReader；
导入org.xml.sax.InputSource；
导入oracle.sql.CLOB；
导入java.io.IOException；
导入org.xml.sax.SAXException；
导入java.sql.SQLException；
导入java.lang.IllegalArgumentException；
导入oracle.xml.parser.v2.XMLParseException；
导入javax.xml.parsers.parserConfiguration异常；
导入java.io.*；
公共类XmlValidator
{
静态最终字符串JAXP_模式_语言=”http://java.sun.com/xml/jaxp/properties/schemaLanguage";
静态最终字符串W3C_XML_模式=”http://www.w3.org/2001/XMLSchema"; 
静态最终字符串JAXP_模式_源=”http://java.sun.com/xml/jaxp/properties/schemaSource";
公共静态void validatedDocument（int schemasource、oracle.sql.CLOB schemadoc、oracle.sql.CLOB schemadoc1、oracle.sql.CLOB xmldoc）引发SAXException、IOException、SQLException、ParserConfiguration异常、XMLParseException、IllegalArgumentException{
尝试
{              
File myfile=新文件（“.//XML//common_types.xsd”）；
如果（myfile.exists（））
{
log（“validatedDocument”，“file size”+Long.toString（myfile.length（））；
}
/*否则
{
log（“validatedDocument”，“文件不存在”）；
}*/
服务日志（“ValidatedDocument”、“1”）；
SAXParserFactory=SAXParserFactory.newInstance（）；
工厂设置验证（true）；
factory.setNamespaceAware（true）；
服务日志（“ValidatedDocument”、“2”）；
SAXParser SAXParser=factory.newSAXParser（）；
setProperty（JAXP_模式语言，W3C_XML_模式）；
如果（schemasource==0）
{
InputSource schemaIs=新的InputSource（schemadoc.getCharacterStream（））；
InputSource schemaIs1=新的InputSource（schemadoc1.getCharacterStream（））；
InputSource[]模式={schemaIs，schemaIs1}；
//setProperty（JAXP_SCHEMA_源，schemaIs）；
setProperty（JAXP_SCHEMA_源，schemas）；
}
其他的
{            
setProperty（JAXP_SCHEMA_SOURCE，“.//XML//common_types.xsd”）；
}
XMLReader=saxParser.getXMLReader（）；
//ПичаааааааXMLаааааа
InputSource documentIs=新的InputSource（xmldoc.getCharacterStream（））；
服务日志（“ValidatedDocument”、“3”）；
//Запуск разбора
解析（documentIs）；
服务日志（“ValidatedDocument”、“4”）；
documentIs=null；
}
/*捕获（SAXE异常）
{
服务日志（“ValidatedDocument”、“SAXException”）；
服务日志（“ValidatedDocument”，“文档无效，因为”）；
日志（“validatedDocument”，e.getMessage（））；
投掷（e）；
}*/          
捕获（ParserConfiguration异常e）
{
服务日志（“ValidatedDocument”、“ParserConfiguration异常”）；
投掷（e）；
}
捕获（IOE异常）
{
服务日志（“ValidatedDocument”、“IOException”）；
投掷（e）；
}
catch（xmlparse异常）
{
日志（“validatedDocument”、“XMLParseException”）；
日志（“validatedDocument”，e.getMessage（））；
StackTraceElement[]stack=e.getStackTrace（）；
for（int i=0；i

从java stacktrace获得的其他信息：

文件名：XMLError.java，类名：oracle.xml.parser.v2.XMLError，方法名：flushErrors1，行：320 文件名：NonValidatingParser.java，类名：oracle.xml.parser.v2.NonValidatingParser，方法名：parseDocument，行：300 文件名：XMLParser.java，类名：oracle.xml.parser.v2.XMLParser，方法名：parse，行：200 文件名：XMLTOOLS，类名：XmlValidator，方法名：ValidatedDocument，行：86

我的oracle版本是oracle Database 10g Enterprise Edition 10.2.0.1.0版-Prod 但我的目标是让它从9开始在所有版本上运行更新：

---

因此，您将这些文件作为CLOB加载到数据库中。当您将它们插入数据库时，您是否尊重它们的xml编码？

根据您的stacktrace，我看到正在使用非验证解析器。尽管你没有提到这是一个问题，但这是出乎意料的。我知道xmlparserv2有一个验证解析器，所以我看了一下d

XMLParser()
{
    parser = new NonValidatingParser();
}

    ............
    if(s == "http://java.sun.com/xml/jaxp/properties/schemaSource")
        schemaSource = obj;
    else
    if(s == "http://java.sun.com/xml/jaxp/properties/schemaLanguage")
    {
        if(((String)obj).equals("http://www.w3.org/2001/XMLSchema"))
            setValidationMode(3);
        getSchemaValidator().setJAXP(true);
    }
    .......................
    attributes.put(s, obj);
}