Hvordan validerer man en XML-fil ved hjælp af Java med en XSD med en include?
du skal bruge en LSResourceResolver for at dette virker. tag et kig på eksempelkoden nedenfor.
en valideringsmetode:
// note that if your XML already declares the XSD to which it has to conform, then there's no need to declare the schemaName here
void validate(String xml, String schemaName) throws Exception {
DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
builderFactory.setNamespaceAware(true);
DocumentBuilder parser = builderFactory
.newDocumentBuilder();
// parse the XML into a document object
Document document = parser.parse(new StringInputStream(xml));
SchemaFactory factory = SchemaFactory
.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
// associate the schema factory with the resource resolver, which is responsible for resolving the imported XSD's
factory.setResourceResolver(new ResourceResolver());
// note that if your XML already declares the XSD to which it has to conform, then there's no need to create a validator from a Schema object
Source schemaFile = new StreamSource(getClass().getClassLoader()
.getResourceAsStream(schemaName));
Schema schema = factory.newSchema(schemaFile);
Validator validator = schema.newValidator();
validator.validate(new DOMSource(document));
}
implementeringen af ressourceresolveren:
public class ResourceResolver implements LSResourceResolver {
public LSInput resolveResource(String type, String namespaceURI,
String publicId, String systemId, String baseURI) {
// note: in this sample, the XSD's are expected to be in the root of the classpath
InputStream resourceAsStream = this.getClass().getClassLoader()
.getResourceAsStream(systemId);
return new Input(publicId, systemId, resourceAsStream);
}
}
Inputimplementeringen returneret af ressourceopløsningen:
public class Input implements LSInput {
private String publicId;
private String systemId;
public String getPublicId() {
return publicId;
}
public void setPublicId(String publicId) {
this.publicId = publicId;
}
public String getBaseURI() {
return null;
}
public InputStream getByteStream() {
return null;
}
public boolean getCertifiedText() {
return false;
}
public Reader getCharacterStream() {
return null;
}
public String getEncoding() {
return null;
}
public String getStringData() {
synchronized (inputStream) {
try {
byte[] input = new byte[inputStream.available()];
inputStream.read(input);
String contents = new String(input);
return contents;
} catch (IOException e) {
e.printStackTrace();
System.out.println("Exception " + e);
return null;
}
}
}
public void setBaseURI(String baseURI) {
}
public void setByteStream(InputStream byteStream) {
}
public void setCertifiedText(boolean certifiedText) {
}
public void setCharacterStream(Reader characterStream) {
}
public void setEncoding(String encoding) {
}
public void setStringData(String stringData) {
}
public String getSystemId() {
return systemId;
}
public void setSystemId(String systemId) {
this.systemId = systemId;
}
public BufferedInputStream getInputStream() {
return inputStream;
}
public void setInputStream(BufferedInputStream inputStream) {
this.inputStream = inputStream;
}
private BufferedInputStream inputStream;
public Input(String publicId, String sysId, InputStream input) {
this.publicId = publicId;
this.systemId = sysId;
this.inputStream = new BufferedInputStream(input);
}
}
Det accepterede svar er helt ok, men virker ikke med Java 8 uden nogle modifikationer. Det ville også være rart at kunne angive en basissti, hvorfra de importerede skemaer læses.
Jeg har brugt følgende kode i min Java 8, som gør det muligt at specificere en anden indlejret skemasti end rodstien:
import com.sun.org.apache.xerces.internal.dom.DOMInputImpl;
import org.w3c.dom.ls.LSInput;
import org.w3c.dom.ls.LSResourceResolver;
import java.io.InputStream;
import java.util.Objects;
public class ResourceResolver implements LSResourceResolver {
private String basePath;
public ResourceResolver(String basePath) {
this.basePath = basePath;
}
@Override
public LSInput resolveResource(String type, String namespaceURI, String publicId, String systemId, String baseURI) {
// note: in this sample, the XSD's are expected to be in the root of the classpath
InputStream resourceAsStream = this.getClass().getClassLoader()
.getResourceAsStream(buildPath(systemId));
Objects.requireNonNull(resourceAsStream, String.format("Could not find the specified xsd file: %s", systemId));
return new DOMInputImpl(publicId, systemId, baseURI, resourceAsStream, "UTF-8");
}
private String buildPath(String systemId) {
return basePath == null ? systemId : String.format("%s/%s", basePath, systemId);
}
}
Denne implementering giver også brugeren en meningsfuld besked, hvis skemaet ikke kan læses.
Jeg var nødt til at foretage nogle ændringer til dette indlæg af AMegmondoEmber
Min hovedskemafil havde nogle inkluderer fra søskendemapper, og de inkluderede filer havde også nogle inkluderer fra deres lokale mapper. Jeg skulle også spore basisressourcestien og relative sti for den aktuelle ressource. Denne kode virker for mig, men husk venligst, at den antager, at alle xsd-filer har et unikt navn. Hvis du har nogle xsd-filer med samme navn, men forskelligt indhold på forskellige stier, vil det sandsynligvis give dig problemer.
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.ls.LSInput;
import org.w3c.dom.ls.LSResourceResolver;
/**
* The Class ResourceResolver.
*/
public class ResourceResolver implements LSResourceResolver {
/** The logger. */
private final Logger logger = LoggerFactory.getLogger(this.getClass());
/** The schema base path. */
private final String schemaBasePath;
/** The path map. */
private Map<String, String> pathMap = new HashMap<String, String>();
/**
* Instantiates a new resource resolver.
*
* @param schemaBasePath the schema base path
*/
public ResourceResolver(String schemaBasePath) {
this.schemaBasePath = schemaBasePath;
logger.warn("This LSResourceResolver implementation assumes that all XSD files have a unique name. "
+ "If you have some XSD files with same name but different content (at different paths) in your schema structure, "
+ "this resolver will fail to include the other XSD files except the first one found.");
}
/* (non-Javadoc)
* @see org.w3c.dom.ls.LSResourceResolver#resolveResource(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String)
*/
@Override
public LSInput resolveResource(String type, String namespaceURI,
String publicId, String systemId, String baseURI) {
// The base resource that includes this current resource
String baseResourceName = null;
String baseResourcePath = null;
// Extract the current resource name
String currentResourceName = systemId.substring(systemId
.lastIndexOf("/") + 1);
// If this resource hasn't been added yet
if (!pathMap.containsKey(currentResourceName)) {
if (baseURI != null) {
baseResourceName = baseURI
.substring(baseURI.lastIndexOf("/") + 1);
}
// we dont need "./" since getResourceAsStream cannot understand it
if (systemId.startsWith("./")) {
systemId = systemId.substring(2, systemId.length());
}
// If the baseResourcePath has already been discovered, get that
// from pathMap
if (pathMap.containsKey(baseResourceName)) {
baseResourcePath = pathMap.get(baseResourceName);
} else {
// The baseResourcePath should be the schemaBasePath
baseResourcePath = schemaBasePath;
}
// Read the resource as input stream
String normalizedPath = getNormalizedPath(baseResourcePath, systemId);
InputStream resourceAsStream = this.getClass().getClassLoader()
.getResourceAsStream(normalizedPath);
// if the current resource is not in the same path with base
// resource, add current resource's path to pathMap
if (systemId.contains("/")) {
pathMap.put(currentResourceName, normalizedPath.substring(0,normalizedPath.lastIndexOf("/")+1));
} else {
// The current resource should be at the same path as the base
// resource
pathMap.put(systemId, baseResourcePath);
}
Scanner s = new Scanner(resourceAsStream).useDelimiter("\\A");
String s1 = s.next().replaceAll("\\n", " ") // the parser cannot understand elements broken down multiple lines e.g. (<xs:element \n name="buxing">)
.replace("\\t", " ") // these two about whitespaces is only for decoration
.replaceAll("\\s+", " ").replaceAll("[^\\x20-\\x7e]", ""); // some files has a special character as a first character indicating utf-8 file
InputStream is = new ByteArrayInputStream(s1.getBytes());
return new LSInputImpl(publicId, systemId, is); // same as Input class
}
// If this resource has already been added, do not add the same resource again. It throws
// "org.xml.sax.SAXParseException: sch-props-correct.2: A schema cannot contain two global components with the same name; this schema contains two occurrences of ..."
// return null instead.
return null;
}
/**
* Gets the normalized path.
*
* @param basePath the base path
* @param relativePath the relative path
* @return the normalized path
*/
private String getNormalizedPath(String basePath, String relativePath){
if(!relativePath.startsWith("../")){
return basePath + relativePath;
}
else{
while(relativePath.startsWith("../")){
basePath = basePath.substring(0,basePath.substring(0, basePath.length()-1).lastIndexOf("/")+1);
relativePath = relativePath.substring(3);
}
return basePath+relativePath;
}
}
}
