import com.helger.commons.io.resource.FileSystemResource; //导入依赖的package包/类
@Nullable
public static InputSource create (@Nonnull final IReadableResource aResource)
{
  if (aResource instanceof FileSystemResource)
  {
    final File aFile = aResource.getAsFile ();
    if (aFile != null)
    {
      // Potentially use memory mapped files
      final InputSource ret = create (FileHelper.getInputStream (aFile));
      if (ret != null)
      {
        // Ensure system ID is present - may be helpful for resource
        // resolution
        final URL aURL = aResource.getAsURL ();
        if (aURL != null)
          ret.setSystemId (aURL.toExternalForm ());
      }
      return ret;
    }
  }
  return new ReadableResourceSAXInputSource (aResource);
}
 

import com.helger.commons.io.resource.FileSystemResource; //导入依赖的package包/类
public static boolean validateXMLViaPureSchematron2 (@Nonnull final File aSchematronFile,
                                                     @Nonnull final File aXMLFile) throws Exception
{
  // Read the schematron from file
  final PSSchema aSchema = new PSReader (new FileSystemResource (aSchematronFile)).readSchema ();
  if (!aSchema.isValid (new DoNothingPSErrorHandler ()))
    throw new IllegalArgumentException ("Invalid Schematron!");
  // Resolve the query binding to use
  final IPSQueryBinding aQueryBinding = PSQueryBindingRegistry.getQueryBindingOfNameOrThrow (aSchema.getQueryBinding ());
  // Pre-process schema
  final PSPreprocessor aPreprocessor = new PSPreprocessor (aQueryBinding);
  aPreprocessor.setKeepTitles (true);
  final PSSchema aPreprocessedSchema = aPreprocessor.getAsPreprocessedSchema (aSchema);
  // Bind the pre-processed schema
  final IPSBoundSchema aBoundSchema = aQueryBinding.bind (aPreprocessedSchema, null, null, null, null);
  // Read the XML file
  final Document aXMLNode = DOMReader.readXMLDOM (aXMLFile);
  if (aXMLNode == null)
    return false;
  // Perform the validation
  return aBoundSchema.validatePartially (aXMLNode, FileHelper.getAsURLString (aXMLFile)).isValid ();
}
 

import com.helger.commons.io.resource.FileSystemResource; //导入依赖的package包/类
public static void validateAndProduceSVRL (@Nonnull final File aSchematron, final File aXML) throws Exception
{
  // Create the custom parameters
  final ICommonsMap <String, Object> aCustomParameters = new CommonsHashMap <> ();
  aCustomParameters.put ("xyz", "mobile");
  aCustomParameters.put ("expected", "");

  final SchematronResourceSCH aSCH = SchematronResourceSCH.fromFile (aSchematron);

  // Assign custom parameters
  aSCH.setParameters (aCustomParameters);

  if (false)
    System.out.println (XMLWriter.getNodeAsString (aSCH.getXSLTProvider ().getXSLTDocument ()));

  // Perform validation
  final SchematronOutputType aSVRL = aSCH.applySchematronValidationToSVRL (new FileSystemResource (aXML));
  assertNotNull (aSVRL);
  if (false)
    System.out.println (new SVRLMarshaller ().getAsString (aSVRL));
}
 

import com.helger.commons.io.resource.FileSystemResource; //导入依赖的package包/类
@SuppressFBWarnings ("BC_IMPOSSIBLE_INSTANCEOF")
public static void validateAndProduceSVRL (final File schematron, final File xml) throws Exception
{
  final IReadableResource aSchematron = new FileSystemResource (schematron.getAbsoluteFile ());
  final IReadableResource anXMLSource = new FileSystemResource (xml.getAbsoluteFile ());
  final AbstractSchematronResource aSCH = new SchematronResourceSCH (aSchematron);
  if (aSCH instanceof SchematronResourcePure)
    ((SchematronResourcePure) aSCH).setErrorHandler (new LoggingPSErrorHandler ());
  else
    System.out.println (XMLWriter.getNodeAsString (((SchematronResourceSCH) aSCH).getXSLTProvider ()
                                                                                 .getXSLTDocument ()));
  final SchematronOutputType aSVRL = aSCH.applySchematronValidationToSVRL (anXMLSource);
  assertNotNull (aSVRL);
  if (false)
    System.out.println (new SVRLMarshaller ().getAsString (aSVRL));
}
 

import com.helger.commons.io.resource.FileSystemResource; //导入依赖的package包/类
public static void validateAndProduceSVRL (@Nonnull final File aSchematron, final File aXML) throws Exception
{
  final PSSchema aSchema = new PSReader (new FileSystemResource (aSchematron)).readSchema ();
  final PSPreprocessor aPreprocessor = new PSPreprocessor (PSXPathQueryBinding.getInstance ());
  final PSSchema aPreprocessedSchema = aPreprocessor.getAsPreprocessedSchema (aSchema);
  final String sSCH = new PSWriter (new PSWriterSettings ().setXMLWriterSettings (new XMLWriterSettings ())).getXMLString (aPreprocessedSchema);

  if (false)
    System.out.println (sSCH);

  final SchematronResourceSCH aSCH = new SchematronResourceSCH (new ReadableResourceString (sSCH,
                                                                                            StandardCharsets.UTF_8));

  // Perform validation
  final SchematronOutputType aSVRL = aSCH.applySchematronValidationToSVRL (new FileSystemResource (aXML));
  assertNotNull (aSVRL);
  if (false)
    System.out.println (new SVRLMarshaller ().getAsString (aSVRL));
}
 

import com.helger.commons.io.resource.FileSystemResource; //导入依赖的package包/类
public static void main (final String [] args) throws IOException
{
  s_aLogger.info ("Reading");
  final InvoiceType aInvoice = UBL21Reader.invoice ()
                                          .read (new FileSystemResource ("src/test/resources/xml/as2-test-at-gov.xml"));

  final String sNote = StringHelper.getRepeated ('X', 1024);
  final long nNotes = 2 * CGlobal.BYTES_PER_GIGABYTE / sNote.length ();
  s_aLogger.info ("Adding " + nNotes + " notes");
  for (long i = 0; i < nNotes; ++i)
    aInvoice.addNote (new NoteType (sNote));
  s_aLogger.info ("Writing");
  UBL21Writer.invoice ()
             .write (aInvoice,
                     new GZIPOutputStream (new FileSystemResource ("src/test/resources/xml/as2-test-at-gov-2gb.gz").getOutputStream (EAppend.TRUNCATE)));
  s_aLogger.info ("Done");
}
 

import com.helger.commons.io.resource.FileSystemResource; //导入依赖的package包/类
public static boolean validateXMLSchema (@Nonnull final File xsdPath, @Nonnull final File xmlPath)
{
  try
  {
    System.setProperty ("jdk.xml.maxOccurLimit", "9999999");
    final Validator aValidator = XMLSchemaCache.getInstance ().getValidator (new FileSystemResource (xsdPath));
    aValidator.validate (TransformSourceFactory.create (xmlPath));
  }
  catch (final IOException | SAXException e)
  {
    s_aLogger.info ("Exception: " + e.getMessage ());
    return false;
  }
  return true;
}
 

import com.helger.commons.io.resource.FileSystemResource; //导入依赖的package包/类
public static boolean validateXMLSchematron (@Nonnull final File schPath,
                                             @Nonnull final EMode eMode,
                                             @Nonnull final File xmlPath,
                                             @Nullable final File svrlPath)
{
  final FileSystemResource aXML = new FileSystemResource (xmlPath);
  final FileSystemResource aSCH = new FileSystemResource (schPath);

  // Use pure implementation or XSLT to do the conversion?
  final ISchematronResource aSchematron = eMode == EMode.PURE ? new SchematronResourcePure (aSCH)
                                                              : eMode == EMode.XSLT ? new SchematronResourceXSLT (aSCH)
                                                                                    : new SchematronResourceSCH (aSCH);
  final SchematronOutputType aSOT = SchematronHelper.applySchematron (aSchematron, aXML);
  if (aSOT == null)
  {
    s_aLogger.info ("Schematron file " + aSchematron + " is malformed!");
    return false;
  }

  // Write SVRL
  if (svrlPath != null)
    new SVRLMarshaller (false).write (aSOT, new FileSystemResource (svrlPath));

  final ICommonsList <SVRLFailedAssert> aFailedAsserts = SVRLHelper.getAllFailedAssertions (aSOT);
  if (aFailedAsserts.isNotEmpty ())
  {
    s_aLogger.info ("XML does not comply to Schematron!" +
                    (svrlPath != null ? " See SVRL for details: " + svrlPath : ""));
    return false;
  }

  s_aLogger.info ("XML complies to Schematron!");
  return true;
}
 

import com.helger.commons.io.resource.FileSystemResource; //导入依赖的package包/类
@Test
public void testBasic ()
{
  final PD1BusinessCardMarshaller aMarshaller = new PD1BusinessCardMarshaller ();
  assertNotNull (aMarshaller.read (new FileSystemResource ("src/test/resources/example/v1/business-card-test1.xml")));
  assertNotNull (aMarshaller.read (new FileSystemResource ("src/test/resources/example/v1/business-card-example-spec.xml")));
  assertNotNull (aMarshaller.read (new FileSystemResource ("src/test/resources/example/v1/bc-9915-leckma.xml")));
  assertNotNull (aMarshaller.read (new FileSystemResource ("src/test/resources/example/v1/bc-0088-5033466000005.xml")));
}
 

import com.helger.commons.io.resource.FileSystemResource; //导入依赖的package包/类
@Test
public void testBasic ()
{
  final PD2BusinessCardMarshaller aMarshaller = new PD2BusinessCardMarshaller ();
  assertNotNull (aMarshaller.read (new FileSystemResource ("src/test/resources/example/v2/business-card-test1.xml")));
  assertNotNull (aMarshaller.read (new FileSystemResource ("src/test/resources/example/v2/business-card-example-spec.xml")));
  assertNotNull (aMarshaller.read (new FileSystemResource ("src/test/resources/example/v2/bc-9915-leckma.xml")));
  assertNotNull (aMarshaller.read (new FileSystemResource ("src/test/resources/example/v2/bc-0088-5033466000005.xml")));
}
 

import com.helger.commons.io.resource.FileSystemResource; //导入依赖的package包/类
@Test
public void testExternalEntityExpansion () throws SAXException
{
  // Include a dummy file
  final File aFile = new File ("src/test/resources/test1.txt");
  assertTrue (aFile.exists ());
  final String sFileContent = StreamHelper.getAllBytesAsString (new FileSystemResource (aFile),
                                                                StandardCharsets.ISO_8859_1);

  // The XML with XXE problem
  final String sXML = "<?xml version='1.0' encoding='utf-8'?>" +
                      "<!DOCTYPE root [" +
                      " <!ELEMENT root ANY >" +
                      " <!ENTITY xxe SYSTEM \"" +
                      FileHelper.getAsURLString (aFile) +
                      "\" >]>" +
                      "<root>&xxe;</root>";
  final DOMReaderSettings aDRS = new DOMReaderSettings ().setEntityResolver ( (publicId,
                                                                               systemId) -> InputSourceFactory.create (new URLResource (systemId)));

  // Read successful - entity expansion!
  final Document aDoc = DOMReader.readXMLDOM (sXML, aDRS);
  assertNotNull (aDoc);
  assertEquals (sFileContent, aDoc.getDocumentElement ().getTextContent ());

  // Should fail because inline DTD is present
  try
  {
    DOMReader.readXMLDOM (sXML, aDRS.getClone ().setFeatureValues (EXMLParserFeature.AVOID_XXE_SETTINGS));
    fail ();
  }
  catch (final SAXParseException ex)
  {
    // Expected
    assertTrue (ex.getMessage ().contains ("http://apache.org/xml/features/disallow-doctype-decl"));
  }
}
 

import com.helger.commons.io.resource.FileSystemResource; //导入依赖的package包/类
@Test
@SuppressFBWarnings (value = "NP_NONNULL_PARAM_VIOLATION")
public void testRead () throws SAXException
{
  // Read valid
  final ChangeLog aCL = ChangeLogSerializer.readChangeLog (new FileSystemResource ("src/main/resources/" +
                                                                                   CChangeLog.CHANGELOG_XML_FILENAME));
  assertNotNull (aCL);
  assertEquals (new Version (1, 0), aCL.getVersion ());
  assertEquals ("ph-xml", aCL.getComponent ());
  assertTrue (aCL.getAllEntries ().size () > 0);
  assertTrue (aCL.getAllReleases ().size () > 0);
  assertNotNull (aCL.getLatestRelease ());
  for (final EChangeLogCategory eCat : EChangeLogCategory.values ())
    assertNotNull (aCL.getAllEntriesOfCategory (eCat));

  // Read with XML Schema
  final Document aW3CDoc = DOMReader.readXMLDOM (new ClassPathResource (CChangeLog.CHANGELOG_XML_FILENAME),
                                                 new DOMReaderSettings ().setSchema (XMLSchemaCache.getInstance ()
                                                                                                   .getSchema (new ClassPathResource (CChangeLog.CHANGELOG_XSD_10))));
  assertNotNull (aW3CDoc);

  // Read invalid
  assertNull (ChangeLogSerializer.readChangeLog (null));
  assertNull (ChangeLogSerializer.readChangeLog (new ClassPathResource ("does-not-exist.xml")));

  try
  {
    aCL.getAllEntriesOfCategory (null);
    fail ();
  }
  catch (final NullPointerException ex)
  {}
}
 

import com.helger.commons.io.resource.FileSystemResource; //导入依赖的package包/类
/**
 * Trigger the registered custom exception handlers for read errors.
 *
 * @param t
 *        Thrown exception. Never <code>null</code>.
 * @param bIsInitialization
 *        <code>true</code> if this happened during initialization of a new
 *        file, <code>false</code> if it happened during regular reading.
 * @param aFile
 *        The file that was read. May be <code>null</code> for in-memory DAOs.
 */
protected static void triggerExceptionHandlersRead (@Nonnull final Throwable t,
                                                    final boolean bIsInitialization,
                                                    @Nullable final File aFile)
{
  // Custom exception handler for reading
  if (exceptionHandlersRead ().isNotEmpty ())
  {
    final IReadableResource aRes = aFile == null ? null : new FileSystemResource (aFile);
    exceptionHandlersRead ().forEach (aCB -> aCB.onDAOReadException (t, bIsInitialization, aRes));
  }
}
 

import com.helger.commons.io.resource.FileSystemResource; //导入依赖的package包/类
/**
 * Trigger the registered custom exception handlers for read errors.
 *
 * @param t
 *        Thrown exception. Never <code>null</code>.
 * @param sErrorFilename
 *        The filename tried to write to. Never <code>null</code>.
 * @param aDoc
 *        The XML content that should be written. May be <code>null</code> if
 *        the error occurred in XML creation.
 */
protected static void triggerExceptionHandlersWrite (@Nonnull final Throwable t,
                                                     @Nonnull final String sErrorFilename,
                                                     @Nullable final IMicroDocument aDoc)
{
  // Check if a custom exception handler is present
  if (exceptionHandlersWrite ().isNotEmpty ())
  {
    final IReadableResource aRes = new FileSystemResource (sErrorFilename);
    final String sXMLContent = aDoc == null ? "no XML document created" : MicroWriter.getNodeAsString (aDoc);
    exceptionHandlersWrite ().forEach (aCB -> aCB.onDAOWriteException (t, aRes, sXMLContent));
  }
}
 

import com.helger.commons.io.resource.FileSystemResource; //导入依赖的package包/类
@Nonnull
@MustBeLocked (ELockType.WRITE)
private ESuccess _writeWALFile (@Nonnull @Nonempty final List <DATATYPE> aModifiedElements,
                                @Nonnull final EDAOActionType eActionType,
                                @Nonnull @Nonempty final String sWALFilename)
{
  final FileSystemResource aWALRes = m_aIO.getResource (sWALFilename);
  try (final DataOutputStream aDOS = new DataOutputStream (aWALRes.getOutputStream (EAppend.APPEND)))
  {
    // Write action type ID
    StreamHelper.writeSafeUTF (aDOS, eActionType.getID ());
    // Write number of elements
    aDOS.writeInt (aModifiedElements.size ());
    // Write all data elements as XML Strings :)
    for (final DATATYPE aModifiedElement : aModifiedElements)
    {
      final String sElement = convertNativeToWALString (aModifiedElement);
      StreamHelper.writeSafeUTF (aDOS, sElement);
    }
    return ESuccess.SUCCESS;
  }
  catch (final Throwable t)
  {
    s_aLogger.error ("Error writing WAL file " + aWALRes, t);
    triggerExceptionHandlersWrite (t, sWALFilename, (IMicroDocument) null);
  }
  return ESuccess.FAILURE;
}
 

import com.helger.commons.io.resource.FileSystemResource; //导入依赖的package包/类
@Nullable
public static NonBlockingProperties loadProperties (@Nonnull final File aFile)
{
  ValueEnforcer.notNull (aFile, "File");

  return loadProperties (new FileSystemResource (aFile));
}
 

import com.helger.commons.io.resource.FileSystemResource; //导入依赖的package包/类
@Nonnull
private static FileSystemResource _getChildResource (@Nullable final File aBaseFile, @Nonnull final File aSystemFile)
{
  if (aBaseFile == null)
    return new FileSystemResource (aSystemFile);

  final File aParent = aBaseFile.isDirectory () ? aBaseFile : aBaseFile.getParentFile ();
  final File aRealFile = new File (aParent, aSystemFile.getPath ());
  // path is cleaned (canonicalized) inside FileSystemResource
  final FileSystemResource ret = new FileSystemResource (aRealFile);
  return ret;
}
 

import com.helger.commons.io.resource.FileSystemResource; //导入依赖的package包/类
@Test
public void testGetAsFile ()
{
  final URL u = URLHelper.getAsURL ("file:/../dir/include.xml");
  final File f = URLHelper.getAsFile (u);
  assertNotNull (f);
  assertEquals (new File ("/../dir/include.xml").getAbsolutePath (), f.getAbsolutePath ());
  final FileSystemResource fs = new FileSystemResource (f);
  assertEquals (new File ("/dir/include.xml").getAbsolutePath (), fs.getPath ());
}
 

import com.helger.commons.io.resource.FileSystemResource; //导入依赖的package包/类
public static boolean readModifyAndWrite (@Nonnull final File aSchematronFile) throws Exception
{
  final PSSchema aSchema = new PSReader (new FileSystemResource (aSchematronFile)).readSchema ();
  final PSTitle aTitle = new PSTitle ();
  aTitle.addText ("Created by ph-schematron");
  aSchema.setTitle (aTitle);
  return MicroWriter.writeToFile (aSchema.getAsMicroElement (), aSchematronFile).isSuccess ();
}
 

import com.helger.commons.io.resource.FileSystemResource; //导入依赖的package包/类
@Test
public void testInvalidSchematron ()
{
  assertFalse (new SchematronResourceSCH (new ClassPathResource ("test-sch/invalid01.sch")).isValidSchematron ());
  assertFalse (new SchematronResourceSCH (new ClassPathResource ("test-sch/this.file.does.not.exists")).isValidSchematron ());

  assertFalse (new SchematronResourceSCH (new FileSystemResource ("src/test/resources/test-sch/invalid01.sch")).isValidSchematron ());
  assertFalse (new SchematronResourceSCH (new FileSystemResource ("src/test/resources/test-sch/this.file.does.not.exists")).isValidSchematron ());
}