static {
    SerializerFactory factory;
    String list;
    StringTokenizer token;
    String className;

    // The default factories are always registered first,
    // any factory specified in the properties file and supporting
    // the same method will override the default factory.
    factory = new SerializerFactoryImpl(Method.XML);
    registerSerializerFactory(factory);
    factory = new SerializerFactoryImpl(Method.HTML);
    registerSerializerFactory(factory);
    factory = new SerializerFactoryImpl(Method.XHTML);
    registerSerializerFactory(factory);
    factory = new SerializerFactoryImpl(Method.TEXT);
    registerSerializerFactory(factory);

    list = System.getProperty(FactoriesProperty);
    if (list != null) {
      token = new StringTokenizer(list, " ;,:");
      while (token.hasMoreTokens()) {
        className = token.nextToken();
        try {
          factory =
              (SerializerFactory)
                  ObjectFactory.newInstance(
                      className, SerializerFactory.class.getClassLoader(), true);
          if (_factories.containsKey(factory.getSupportedMethod()))
            _factories.put(factory.getSupportedMethod(), factory);
        } catch (Exception except) {
        }
      }
    }
  }
  /** Register a serializer factory, keyed by the given method string. */
  public static void registerSerializerFactory(SerializerFactory factory) {
    String method;

    synchronized (_factories) {
      method = factory.getSupportedMethod();
      _factories.put(method, factory);
    }
  }
Пример #3
0
  public void validate(Source source, Result result) throws SAXException, IOException {
    if (result instanceof StreamResult || result == null) {
      final StreamSource streamSource = (StreamSource) source;
      final StreamResult streamResult = (StreamResult) result;
      XMLInputSource input =
          new XMLInputSource(streamSource.getPublicId(), streamSource.getSystemId(), null);
      input.setByteStream(streamSource.getInputStream());
      input.setCharacterStream(streamSource.getReader());

      // Gets the parser configuration. We'll create and initialize a new one, if we
      // haven't created one before or if the previous one was garbage collected.
      boolean newConfig = false;
      XMLParserConfiguration config = (XMLParserConfiguration) fConfiguration.get();
      if (config == null) {
        config = initialize();
        newConfig = true;
      }
      // If settings have changed on the component manager, refresh the error handler and entity
      // resolver.
      else if (fComponentManager.getFeature(PARSER_SETTINGS)) {
        config.setProperty(ENTITY_RESOLVER, fComponentManager.getProperty(ENTITY_RESOLVER));
        config.setProperty(ERROR_HANDLER, fComponentManager.getProperty(ERROR_HANDLER));
        config.setProperty(SECURITY_MANAGER, fComponentManager.getProperty(SECURITY_MANAGER));
      }

      // prepare for parse
      fComponentManager.reset();

      if (streamResult != null) {
        if (fSerializerFactory == null) {
          fSerializerFactory = SerializerFactory.getSerializerFactory(Method.XML);
        }

        // there doesn't seem to be a way to reset a serializer, so we need to make
        // a new one each time.
        Serializer ser;
        if (streamResult.getWriter() != null) {
          ser = fSerializerFactory.makeSerializer(streamResult.getWriter(), new OutputFormat());
        } else if (streamResult.getOutputStream() != null) {
          ser =
              fSerializerFactory.makeSerializer(streamResult.getOutputStream(), new OutputFormat());
        } else if (streamResult.getSystemId() != null) {
          String uri = streamResult.getSystemId();
          OutputStream out = XMLEntityManager.createOutputStream(uri);
          ser = fSerializerFactory.makeSerializer(out, new OutputFormat());
        } else {
          throw new IllegalArgumentException(
              JAXPValidationMessageFormatter.formatMessage(
                  fComponentManager.getLocale(), "StreamResultNotInitialized", null));
        }

        // we're using the parser only as an XNI-to-SAX converter,
        // so that we can use the SAX-based serializer
        SAXParser parser = (SAXParser) fParser.get();
        if (newConfig || parser == null) {
          parser = new SAXParser(config);
          fParser = new SoftReference(parser);
        } else {
          parser.reset();
        }
        config.setDocumentHandler(fSchemaValidator);
        fSchemaValidator.setDocumentHandler(parser);
        parser.setContentHandler(ser.asContentHandler());
      } else {
        fSchemaValidator.setDocumentHandler(null);
      }

      try {
        config.parse(input);
      } catch (XMLParseException e) {
        throw Util.toSAXParseException(e);
      } catch (XNIException e) {
        throw Util.toSAXException(e);
      } finally {
        // release the references to the SAXParser and Serializer
        fSchemaValidator.setDocumentHandler(null);
      }

      return;
    }
    throw new IllegalArgumentException(
        JAXPValidationMessageFormatter.formatMessage(
            fComponentManager.getLocale(),
            "SourceResultMismatch",
            new Object[] {source.getClass().getName(), result.getClass().getName()}));
  }