Java XSOMParser类代码示例

import com.sun.xml.xsom.parser.XSOMParser; //导入依赖的package包/类
private XSOMParser createSchemaParser() {
	XSOMParser parser = new XSOMParser();
	if (entityResolver == null) {
		entityResolver = prismContext.getEntityResolver();
		if (entityResolver == null) {
			throw new IllegalStateException(
					"Entity resolver is not set (even tried to pull it from prism context)");
		}
	}
	SchemaHandler errorHandler = new SchemaHandler(entityResolver);
	parser.setErrorHandler(errorHandler);
	parser.setAnnotationParser(new DomAnnotationParserFactory());
	parser.setEntityResolver(errorHandler);

	return parser;
}
 

import com.sun.xml.xsom.parser.XSOMParser; //导入依赖的package包/类
private XSSchemaSet getSchemaSet()
	throws IOException, SAXException
{
	if ( schemaSet == null ) {
		XSOMParser schemaParser = new XSOMParser();
		ValueVector vec = getParameterVector( "schema" );
		if ( vec.size() > 0 ) {
			for( Value v : vec ) {
				schemaParser.parse( new File( v.strValue() ) );
			}
		}
		parseWSDLTypes( schemaParser );
		schemaSet = schemaParser.getResult();
		String nsPrefix = "jolie";
		int i = 1;
		for( XSSchema schema : schemaSet.getSchemas() ) {
			if ( !schema.getTargetNamespace().equals( XMLConstants.W3C_XML_SCHEMA_NS_URI ) ) {
				namespacePrefixMap.put( schema.getTargetNamespace(), nsPrefix + i++ );
			}
		}
	}

	return schemaSet;
}
 

import com.sun.xml.xsom.parser.XSOMParser; //导入依赖的package包/类
public ParserContext( XSOMParser owner, XMLParser parser ) {
    this.owner = owner;
    this.parser = parser;

    try {
        parse(new InputSource(ParserContext.class.getResource("datatypes.xsd").toExternalForm()));

        SchemaImpl xs = (SchemaImpl)
            schemaSet.getSchema("http://www.w3.org/2001/XMLSchema");
        xs.addSimpleType(schemaSet.anySimpleType,true);
        xs.addComplexType(schemaSet.anyType,true);
    } catch( SAXException e ) {
        // this must be a bug of XSOM
        if(e.getException()!=null)
            e.getException().printStackTrace();
        else
            e.printStackTrace();
        throw new InternalError();
    }
}
 

import com.sun.xml.xsom.parser.XSOMParser; //导入依赖的package包/类
public static boolean validateIsFaultType(NamespaceType namespace, SchemaElementType type, File baseSchemaDir)
    throws Exception {
    XSOMParser parser = new XSOMParser();
    parser.setErrorHandler(new DefaultErrorHandler());

    parser.parse(new File(baseSchemaDir.getAbsolutePath() + File.separator + namespace.getLocation()));

    XSSchemaSet sset = parser.getResult();
    XSComplexType bfct = sset.getComplexType(IntroduceConstants.BASEFAULTS_NAMESPACE, "BaseFaultType");
    XSElementDecl ct = sset.getElementDecl(namespace.getNamespace(), type.getType());
    if (ct.getType().isDerivedFrom(bfct)) {
        return true;
    } else {
        return false;
    }
}
 

import com.sun.xml.xsom.parser.XSOMParser; //导入依赖的package包/类
private void parseWSDLTypes( XSOMParser schemaParser )
	throws IOException
{
	Definition definition = getWSDLDefinition();
	if ( definition != null ) {
		Types types = definition.getTypes();
		if ( types != null ) {
			List<ExtensibilityElement> list = types.getExtensibilityElements();
			for( ExtensibilityElement element : list ) {
				if ( element instanceof SchemaImpl ) {
					Element schemaElement = ((SchemaImpl) element).getElement();
					Map<String, String> namespaces = definition.getNamespaces();
					for( Entry<String, String> entry : namespaces.entrySet() ) {
						if ( entry.getKey().equals( "xmlns" ) || entry.getKey().trim().isEmpty() ) {
							continue;
						}
						if ( schemaElement.getAttribute( "xmlns:" + entry.getKey() ).isEmpty() ) {
							schemaElement.setAttribute( "xmlns:" + entry.getKey(), entry.getValue() );
						}
					}
					parseSchemaElement( definition, schemaElement, schemaParser );
				}
			}
		}
	}
}
 

import com.sun.xml.xsom.parser.XSOMParser; //导入依赖的package包/类
public XSSchemaSet parse(String resource) throws Exception {
	final XSOMParser parser = new XSOMParser();
	parser.setErrorHandler(null);
	parser.setEntityResolver(null);

	final URL resourceUrl = getClass().getClassLoader().getResource(
			resource);
	// parser.parseSchema(
	//				
	// new File("myschema.xsd"));
	// parser.parseSchema( new File("XHTML.xsd"));
	parser.parse(resourceUrl);
	XSSchemaSet sset = parser.getResult();
	return sset;
}
 

import com.sun.xml.xsom.parser.XSOMParser; //导入依赖的package包/类
private void initXsom() throws IOException {
try {
	SchemaImpl schema = (SchemaImpl) wsdlObject.getTypes()
			.getExtensibilityElements().get(0);

	Element el = schema.getElement();
	InputStream is = prepareSchema(el);
	XSOMParser parser = new XSOMParser();

	// is needed to read element documentations which are inside
	// annotations
	parser.setAnnotationParser(new AnnotationFactory());

	parser.parse(is);

	String targetNamespace = wsdlObject.getTargetNamespace();

	if (parser.getResult() == null)
		throw new IOException(
				"Could not initialize XML Schema");
	schemaObject = parser.getResult().getSchema(targetNamespace);

	addSchemaElements();

} catch (TransformerException | SAXException e) {
	throw new IOException("Problem initializing XML Schema.", e);
}

  }
 

import com.sun.xml.xsom.parser.XSOMParser; //导入依赖的package包/类
private XSSimpleType parse ( SchemaSimpleType schemaSimpleType ) {

        ClassLoader cldr = this.getClass().getClassLoader();

        InputStream resourceXMLSchema = cldr.getResourceAsStream( schemaSimpleType.getSchemaFilePath() );

        File localXMLSchema = new File( schemaSimpleType.getTypeName() + ".xsd" );
        try {
            InputStream in = resourceXMLSchema;
            // Overwrite the file.
            OutputStream out = new FileOutputStream( localXMLSchema );

            while (in.available() > 0) {
                byte[] buf = new byte[1024];
                int len;
                while ((len = in.read( buf )) > 0) {
                    out.write( buf, 0, len );
                }
            }
            in.close();
            out.close();

        } catch (IOException iOException) {
        }


        XSSimpleType st = null;
        try {
            XSOMParser parser = new XSOMParser();
            parser.parse( localXMLSchema );
            XSSchemaSet schemaSet = parser.getResult();
            XSSchema xsSchema = schemaSet.getSchema( 1 );

            st = xsSchema.getSimpleType( schemaSimpleType.getTypeName() );

        } catch (Exception exp) {
            exp.printStackTrace( System.out );
        }

        localXMLSchema.delete();

        return st;
    }