java.security.interfaces.DSAKey#com.sun.org.apache.xml.internal.security.utils.JavaUtils源码实例Demo

/**
 * Registers implementing class of the Transform algorithm with algorithmURI
 *
 * @param algorithmURI algorithmURI URI representation of <code>SignatureAlgorithm</code>.
 * @param implementingClass <code>implementingClass</code> the implementing class of
 * {@link SignatureAlgorithmSpi}
 * @throws AlgorithmAlreadyRegisteredException if specified algorithmURI is already registered
 * @throws XMLSignatureException
 * @throws SecurityException if a security manager is installed and the
 *    caller does not have permission to register the signature algorithm
 */
public static void register(String algorithmURI, Class<? extends SignatureAlgorithmSpi> implementingClass)
   throws AlgorithmAlreadyRegisteredException, ClassNotFoundException,
       XMLSignatureException {
    JavaUtils.checkRegisterPermission();
    if (log.isLoggable(java.util.logging.Level.FINE)) {
        log.log(java.util.logging.Level.FINE, "Try to register " + algorithmURI + " " + implementingClass);
    }

    // are we already registered?
    Class<? extends SignatureAlgorithmSpi> registeredClass = algorithmHash.get(algorithmURI);
    if (registeredClass != null) {
        Object exArgs[] = { algorithmURI, registeredClass };
        throw new AlgorithmAlreadyRegisteredException(
            "algorithm.alreadyRegistered", exArgs
        );
    }
    algorithmHash.put(algorithmURI, implementingClass);
}
 

/**
 * Registers implementing class of the Transform algorithm with algorithmURI
 *
 * @param algorithmURI algorithmURI URI representation of <code>Transform algorithm</code>
 * @param implementingClass <code>implementingClass</code> the implementing
 * class of {@link TransformSpi}
 * @throws AlgorithmAlreadyRegisteredException if specified algorithmURI
 * is already registered
 * @throws SecurityException if a security manager is installed and the
 *    caller does not have permission to register the transform
 */
@SuppressWarnings("unchecked")
public static void register(String algorithmURI, String implementingClass)
    throws AlgorithmAlreadyRegisteredException, ClassNotFoundException,
        InvalidTransformException {
    JavaUtils.checkRegisterPermission();
    // are we already registered?
    Class<? extends TransformSpi> transformSpi = transformSpiHash.get(algorithmURI);
    if (transformSpi != null) {
        Object exArgs[] = { algorithmURI, transformSpi };
        throw new AlgorithmAlreadyRegisteredException("algorithm.alreadyRegistered", exArgs);
    }
    Class<? extends TransformSpi> transformSpiClass =
        (Class<? extends TransformSpi>)
            ClassLoaderUtils.loadClass(implementingClass, Transform.class);
    transformSpiHash.put(algorithmURI, transformSpiClass);
}
 

/**
 * Registers implementing class of the Transform algorithm with algorithmURI
 *
 * @param algorithmURI algorithmURI URI representation of <code>Transform algorithm</code>
 * @param implementingClass <code>implementingClass</code> the implementing
 * class of {@link TransformSpi}
 * @throws AlgorithmAlreadyRegisteredException if specified algorithmURI
 * is already registered
 * @throws SecurityException if a security manager is installed and the
 *    caller does not have permission to register the transform
 */
@SuppressWarnings("unchecked")
public static void register(String algorithmURI, String implementingClass)
    throws AlgorithmAlreadyRegisteredException, ClassNotFoundException,
        InvalidTransformException {
    JavaUtils.checkRegisterPermission();
    // are we already registered?
    Class<? extends TransformSpi> transformSpi = transformSpiHash.get(algorithmURI);
    if (transformSpi != null) {
        Object exArgs[] = { algorithmURI, transformSpi };
        throw new AlgorithmAlreadyRegisteredException("algorithm.alreadyRegistered", exArgs);
    }
    Class<? extends TransformSpi> transformSpiClass =
        (Class<? extends TransformSpi>)
            ClassLoaderUtils.loadClass(implementingClass, Transform.class);
    transformSpiHash.put(algorithmURI, transformSpiClass);
}
 

/**
 * Registers implementing class of the Transform algorithm with algorithmURI
 *
 * @param algorithmURI algorithmURI URI representation of <code>Transform algorithm</code>
 * @param implementingClass <code>implementingClass</code> the implementing
 * class of {@link TransformSpi}
 * @throws AlgorithmAlreadyRegisteredException if specified algorithmURI
 * is already registered
 * @throws SecurityException if a security manager is installed and the
 *    caller does not have permission to register the transform
 */
@SuppressWarnings("unchecked")
public static void register(String algorithmURI, String implementingClass)
    throws AlgorithmAlreadyRegisteredException, ClassNotFoundException,
        InvalidTransformException {
    JavaUtils.checkRegisterPermission();
    // are we already registered?
    Class<? extends TransformSpi> transformSpi = transformSpiHash.get(algorithmURI);
    if (transformSpi != null) {
        Object exArgs[] = { algorithmURI, transformSpi };
        throw new AlgorithmAlreadyRegisteredException("algorithm.alreadyRegistered", exArgs);
    }
    Class<? extends TransformSpi> transformSpiClass =
        (Class<? extends TransformSpi>)
            ClassLoaderUtils.loadClass(implementingClass, Transform.class);
    transformSpiHash.put(algorithmURI, transformSpiClass);
}
 

/**
 * Method register
 *
 * @param algorithmURI
 * @param implementingClass
 * @throws AlgorithmAlreadyRegisteredException
 * @throws SecurityException if a security manager is installed and the
 *    caller does not have permission to register the canonicalizer
 */
@SuppressWarnings("unchecked")
public static void register(String algorithmURI, String implementingClass)
    throws AlgorithmAlreadyRegisteredException, ClassNotFoundException {
    JavaUtils.checkRegisterPermission();
    // check whether URI is already registered
    Class<? extends CanonicalizerSpi> registeredClass =
        canonicalizerHash.get(algorithmURI);

    if (registeredClass != null)  {
        Object exArgs[] = { algorithmURI, registeredClass };
        throw new AlgorithmAlreadyRegisteredException("algorithm.alreadyRegistered", exArgs);
    }

    canonicalizerHash.put(
        algorithmURI, (Class<? extends CanonicalizerSpi>)Class.forName(implementingClass)
    );
}
 

/**
 * Method register
 *
 * @param algorithmURI
 * @param implementingClass
 * @throws AlgorithmAlreadyRegisteredException
 * @throws SecurityException if a security manager is installed and the
 *    caller does not have permission to register the canonicalizer
 */
@SuppressWarnings("unchecked")
public static void register(String algorithmURI, String implementingClass)
    throws AlgorithmAlreadyRegisteredException, ClassNotFoundException {
    JavaUtils.checkRegisterPermission();
    // check whether URI is already registered
    Class<? extends CanonicalizerSpi> registeredClass =
        canonicalizerHash.get(algorithmURI);

    if (registeredClass != null)  {
        Object exArgs[] = { algorithmURI, registeredClass };
        throw new AlgorithmAlreadyRegisteredException("algorithm.alreadyRegistered", exArgs);
    }

    canonicalizerHash.put(
        algorithmURI, (Class<? extends CanonicalizerSpi>)Class.forName(implementingClass)
    );
}
 

/**
 * Registers implementing class of the Transform algorithm with algorithmURI
 *
 * @param algorithmURI algorithmURI URI representation of <code>SignatureAlgorithm</code>.
 * @param implementingClass <code>implementingClass</code> the implementing class of
 * {@link SignatureAlgorithmSpi}
 * @throws AlgorithmAlreadyRegisteredException if specified algorithmURI is already registered
 * @throws XMLSignatureException
 * @throws SecurityException if a security manager is installed and the
 *    caller does not have permission to register the signature algorithm
 */
public static void register(String algorithmURI, Class<? extends SignatureAlgorithmSpi> implementingClass)
   throws AlgorithmAlreadyRegisteredException, ClassNotFoundException,
       XMLSignatureException {
    JavaUtils.checkRegisterPermission();
    if (log.isLoggable(java.util.logging.Level.FINE)) {
        log.log(java.util.logging.Level.FINE, "Try to register " + algorithmURI + " " + implementingClass);
    }

    // are we already registered?
    Class<? extends SignatureAlgorithmSpi> registeredClass = algorithmHash.get(algorithmURI);
    if (registeredClass != null) {
        Object exArgs[] = { algorithmURI, registeredClass };
        throw new AlgorithmAlreadyRegisteredException(
            "algorithm.alreadyRegistered", exArgs
        );
    }
    algorithmHash.put(algorithmURI, implementingClass);
}
 

/**
 * Registers implementing class of the Transform algorithm with algorithmURI
 *
 * @param algorithmURI algorithmURI URI representation of <code>SignatureAlgorithm</code>.
 * @param implementingClass <code>implementingClass</code> the implementing class of
 * {@link SignatureAlgorithmSpi}
 * @throws AlgorithmAlreadyRegisteredException if specified algorithmURI is already registered
 * @throws XMLSignatureException
 * @throws SecurityException if a security manager is installed and the
 *    caller does not have permission to register the signature algorithm
 */
public static void register(String algorithmURI, Class<? extends SignatureAlgorithmSpi> implementingClass)
   throws AlgorithmAlreadyRegisteredException, ClassNotFoundException,
       XMLSignatureException {
    JavaUtils.checkRegisterPermission();
    if (log.isLoggable(java.util.logging.Level.FINE)) {
        log.log(java.util.logging.Level.FINE, "Try to register " + algorithmURI + " " + implementingClass);
    }

    // are we already registered?
    Class<? extends SignatureAlgorithmSpi> registeredClass = algorithmHash.get(algorithmURI);
    if (registeredClass != null) {
        Object exArgs[] = { algorithmURI, registeredClass };
        throw new AlgorithmAlreadyRegisteredException(
            "algorithm.alreadyRegistered", exArgs
        );
    }
    algorithmHash.put(algorithmURI, implementingClass);
}
 

/**
 * Registers implementing class of the Transform algorithm with algorithmURI
 *
 * @param algorithmURI algorithmURI URI representation of <code>SignatureAlgorithm</code>.
 * @param implementingClass <code>implementingClass</code> the implementing class of
 * {@link SignatureAlgorithmSpi}
 * @throws AlgorithmAlreadyRegisteredException if specified algorithmURI is already registered
 * @throws XMLSignatureException
 * @throws SecurityException if a security manager is installed and the
 *    caller does not have permission to register the signature algorithm
 */
public static void register(String algorithmURI, Class<? extends SignatureAlgorithmSpi> implementingClass)
   throws AlgorithmAlreadyRegisteredException, ClassNotFoundException,
       XMLSignatureException {
    JavaUtils.checkRegisterPermission();
    if (log.isLoggable(java.util.logging.Level.FINE)) {
        log.log(java.util.logging.Level.FINE, "Try to register " + algorithmURI + " " + implementingClass);
    }

    // are we already registered?
    Class<? extends SignatureAlgorithmSpi> registeredClass = algorithmHash.get(algorithmURI);
    if (registeredClass != null) {
        Object exArgs[] = { algorithmURI, registeredClass };
        throw new AlgorithmAlreadyRegisteredException(
            "algorithm.alreadyRegistered", exArgs
        );
    }
    algorithmHash.put(algorithmURI, implementingClass);
}
 

/**
 * Method register
 *
 * @param algorithmURI
 * @param implementingClass
 * @throws AlgorithmAlreadyRegisteredException
 * @throws SecurityException if a security manager is installed and the
 *    caller does not have permission to register the canonicalizer
 */
@SuppressWarnings("unchecked")
public static void register(String algorithmURI, String implementingClass)
    throws AlgorithmAlreadyRegisteredException, ClassNotFoundException {
    JavaUtils.checkRegisterPermission();
    // check whether URI is already registered
    Class<? extends CanonicalizerSpi> registeredClass =
        canonicalizerHash.get(algorithmURI);

    if (registeredClass != null)  {
        Object exArgs[] = { algorithmURI, registeredClass };
        throw new AlgorithmAlreadyRegisteredException("algorithm.alreadyRegistered", exArgs);
    }

    canonicalizerHash.put(
        algorithmURI, (Class<? extends CanonicalizerSpi>)Class.forName(implementingClass)
    );
}
 

/**
 * Registers implementing class of the Transform algorithm with algorithmURI
 *
 * @param algorithmURI algorithmURI URI representation of <code>SignatureAlgorithm</code>.
 * @param implementingClass <code>implementingClass</code> the implementing class of
 * {@link SignatureAlgorithmSpi}
 * @throws AlgorithmAlreadyRegisteredException if specified algorithmURI is already registered
 * @throws XMLSignatureException
 * @throws SecurityException if a security manager is installed and the
 *    caller does not have permission to register the signature algorithm
 */
public static void register(String algorithmURI, Class<? extends SignatureAlgorithmSpi> implementingClass)
   throws AlgorithmAlreadyRegisteredException, ClassNotFoundException,
       XMLSignatureException {
    JavaUtils.checkRegisterPermission();
    if (log.isLoggable(java.util.logging.Level.FINE)) {
        log.log(java.util.logging.Level.FINE, "Try to register " + algorithmURI + " " + implementingClass);
    }

    // are we already registered?
    Class<? extends SignatureAlgorithmSpi> registeredClass = algorithmHash.get(algorithmURI);
    if (registeredClass != null) {
        Object exArgs[] = { algorithmURI, registeredClass };
        throw new AlgorithmAlreadyRegisteredException(
            "algorithm.alreadyRegistered", exArgs
        );
    }
    algorithmHash.put(algorithmURI, implementingClass);
}
 

/**
 * Registers implementing class of the Transform algorithm with algorithmURI
 *
 * @param algorithmURI algorithmURI URI representation of <code>SignatureAlgorithm</code>.
 * @param implementingClass <code>implementingClass</code> the implementing class of
 * {@link SignatureAlgorithmSpi}
 * @throws AlgorithmAlreadyRegisteredException if specified algorithmURI is already registered
 * @throws XMLSignatureException
 * @throws SecurityException if a security manager is installed and the
 *    caller does not have permission to register the signature algorithm
 */
public static void register(String algorithmURI, Class<? extends SignatureAlgorithmSpi> implementingClass)
   throws AlgorithmAlreadyRegisteredException, ClassNotFoundException,
       XMLSignatureException {
    JavaUtils.checkRegisterPermission();
    if (log.isLoggable(java.util.logging.Level.FINE)) {
        log.log(java.util.logging.Level.FINE, "Try to register " + algorithmURI + " " + implementingClass);
    }

    // are we already registered?
    Class<? extends SignatureAlgorithmSpi> registeredClass = algorithmHash.get(algorithmURI);
    if (registeredClass != null) {
        Object exArgs[] = { algorithmURI, registeredClass };
        throw new AlgorithmAlreadyRegisteredException(
            "algorithm.alreadyRegistered", exArgs
        );
    }
    algorithmHash.put(algorithmURI, implementingClass);
}
 

/**
 * Registers a ResourceResolverSpi class. This method logs a warning if
 * the class cannot be registered.
 *
 * @param className the name of the ResourceResolverSpi class to be registered
 * @throws SecurityException if a security manager is installed and the
 *    caller does not have permission to register a resource resolver
 */
@SuppressWarnings("unchecked")
public static void register(String className) {
    JavaUtils.checkRegisterPermission();
    try {
        Class<ResourceResolverSpi> resourceResolverClass =
            (Class<ResourceResolverSpi>) Class.forName(className);
        register(resourceResolverClass, false);
    } catch (ClassNotFoundException e) {
        log.log(java.util.logging.Level.WARNING, "Error loading resolver " + className + " disabling it");
    }
}
 

private byte[] getBytesFromInputStream() throws IOException {
    if (bytes != null) {
        return bytes;
    }
    if (inputOctetStreamProxy == null) {
        return null;
    }
    try {
        bytes = JavaUtils.getBytesFromStream(inputOctetStreamProxy);
    } finally {
        inputOctetStreamProxy.close();
    }
    return bytes;
}
 

/**
 * Registers a ResourceResolverSpi instance. This method logs a warning if the class
 * cannot be registered.
 * @param resourceResolverSpi
 * @param start
 * @throws SecurityException if a security manager is installed and the
 *    caller does not have permission to register a resource resolver
 */
public static void register(ResourceResolverSpi resourceResolverSpi, boolean start) {
    JavaUtils.checkRegisterPermission();
    synchronized(resolverList) {
        if (start) {
            resolverList.add(0, new ResourceResolver(resourceResolverSpi));
        } else {
            resolverList.add(new ResourceResolver(resourceResolverSpi));
        }
    }
    if (log.isLoggable(java.util.logging.Level.FINE)) {
        log.log(java.util.logging.Level.FINE, "Registered resolver: " + resourceResolverSpi.toString());
    }
}
 

private byte[] getBytesFromInputStream() throws IOException {
    if (bytes != null) {
        return bytes;
    }
    if (inputOctetStreamProxy == null) {
        return null;
    }
    try {
        bytes = JavaUtils.getBytesFromStream(inputOctetStreamProxy);
    } finally {
        inputOctetStreamProxy.close();
    }
    return bytes;
}
 

/**
 * Method register
 *
 * @param algorithmURI
 * @param implementingClass
 * @throws AlgorithmAlreadyRegisteredException
 * @throws SecurityException if a security manager is installed and the
 *    caller does not have permission to register the canonicalizer
 */
public static void register(String algorithmURI, Class<? extends CanonicalizerSpi> implementingClass)
    throws AlgorithmAlreadyRegisteredException, ClassNotFoundException {
    JavaUtils.checkRegisterPermission();
    // check whether URI is already registered
    Class<? extends CanonicalizerSpi> registeredClass = canonicalizerHash.get(algorithmURI);

    if (registeredClass != null)  {
        Object exArgs[] = { algorithmURI, registeredClass };
        throw new AlgorithmAlreadyRegisteredException("algorithm.alreadyRegistered", exArgs);
    }

    canonicalizerHash.put(algorithmURI, implementingClass);
}
 

/**
 * Method register
 *
 * @param algorithmURI
 * @param implementingClass
 * @throws AlgorithmAlreadyRegisteredException
 * @throws SecurityException if a security manager is installed and the
 *    caller does not have permission to register the canonicalizer
 */
public static void register(String algorithmURI, Class<? extends CanonicalizerSpi> implementingClass)
    throws AlgorithmAlreadyRegisteredException, ClassNotFoundException {
    JavaUtils.checkRegisterPermission();
    // check whether URI is already registered
    Class<? extends CanonicalizerSpi> registeredClass = canonicalizerHash.get(algorithmURI);

    if (registeredClass != null)  {
        Object exArgs[] = { algorithmURI, registeredClass };
        throw new AlgorithmAlreadyRegisteredException("algorithm.alreadyRegistered", exArgs);
    }

    canonicalizerHash.put(algorithmURI, implementingClass);
}
 

@Override
byte[] preVerifyFormat(Key key, byte[] sig) throws IOException {
    // If signature needs to be in ASN.1 (i.e., if the fallback
    // algorithm will be used to verify the sig), convert the signature
    // to the ASN.1 format
    if (asn1) {
        int size = ((DSAKey) key).getParams().getQ().bitLength();
        return JavaUtils.convertDsaXMLDSIGtoASN1(sig, size / 8);
    } else {
        return sig;
    }
}
 

/**
 * Method register
 *
 * @param algorithmURI
 * @param implementingClass
 * @throws AlgorithmAlreadyRegisteredException
 * @throws SecurityException if a security manager is installed and the
 *    caller does not have permission to register the canonicalizer
 */
public static void register(String algorithmURI, Class<? extends CanonicalizerSpi> implementingClass)
    throws AlgorithmAlreadyRegisteredException, ClassNotFoundException {
    JavaUtils.checkRegisterPermission();
    // check whether URI is already registered
    Class<? extends CanonicalizerSpi> registeredClass = canonicalizerHash.get(algorithmURI);

    if (registeredClass != null)  {
        Object exArgs[] = { algorithmURI, registeredClass };
        throw new AlgorithmAlreadyRegisteredException("algorithm.alreadyRegistered", exArgs);
    }

    canonicalizerHash.put(algorithmURI, implementingClass);
}
 

/**
 * Registers a ResourceResolverSpi class at the beginning of the provider
 * list. This method logs a warning if the class cannot be registered.
 *
 * @param className the name of the ResourceResolverSpi class to be registered
 * @throws SecurityException if a security manager is installed and the
 *    caller does not have permission to register a resource resolver
 */
@SuppressWarnings("unchecked")
public static void registerAtStart(String className) {
    JavaUtils.checkRegisterPermission();
    try {
        Class<ResourceResolverSpi> resourceResolverClass =
            (Class<ResourceResolverSpi>) Class.forName(className);
        register(resourceResolverClass, true);
    } catch (ClassNotFoundException e) {
        log.log(java.util.logging.Level.WARNING, "Error loading resolver " + className + " disabling it");
    }
}
 

/**
 * Registers a ResourceResolverSpi instance. This method logs a warning if the class
 * cannot be registered.
 * @param resourceResolverSpi
 * @param start
 * @throws SecurityException if a security manager is installed and the
 *    caller does not have permission to register a resource resolver
 */
public static void register(ResourceResolverSpi resourceResolverSpi, boolean start) {
    JavaUtils.checkRegisterPermission();
    synchronized(resolverList) {
        if (start) {
            resolverList.add(0, new ResourceResolver(resourceResolverSpi));
        } else {
            resolverList.add(new ResourceResolver(resourceResolverSpi));
        }
    }
    if (log.isLoggable(java.util.logging.Level.FINE)) {
        log.log(java.util.logging.Level.FINE, "Registered resolver: " + resourceResolverSpi.toString());
    }
}
 

/**
 * Registers implementing class of the Transform algorithm with algorithmURI
 *
 * @param algorithmURI algorithmURI URI representation of <code>Transform algorithm</code>
 * @param implementingClass <code>implementingClass</code> the implementing
 * class of {@link TransformSpi}
 * @throws AlgorithmAlreadyRegisteredException if specified algorithmURI
 * is already registered
 * @throws SecurityException if a security manager is installed and the
 *    caller does not have permission to register the transform
 */
public static void register(String algorithmURI, Class<? extends TransformSpi> implementingClass)
    throws AlgorithmAlreadyRegisteredException {
    JavaUtils.checkRegisterPermission();
    // are we already registered?
    Class<? extends TransformSpi> transformSpi = transformSpiHash.get(algorithmURI);
    if (transformSpi != null) {
        Object exArgs[] = { algorithmURI, transformSpi };
        throw new AlgorithmAlreadyRegisteredException("algorithm.alreadyRegistered", exArgs);
    }
    transformSpiHash.put(algorithmURI, implementingClass);
}
 

/**
 * Registers implementing class of the Transform algorithm with algorithmURI
 *
 * @param algorithmURI algorithmURI URI representation of <code>Transform algorithm</code>
 * @param implementingClass <code>implementingClass</code> the implementing
 * class of {@link TransformSpi}
 * @throws AlgorithmAlreadyRegisteredException if specified algorithmURI
 * is already registered
 * @throws SecurityException if a security manager is installed and the
 *    caller does not have permission to register the transform
 */
public static void register(String algorithmURI, Class<? extends TransformSpi> implementingClass)
    throws AlgorithmAlreadyRegisteredException {
    JavaUtils.checkRegisterPermission();
    // are we already registered?
    Class<? extends TransformSpi> transformSpi = transformSpiHash.get(algorithmURI);
    if (transformSpi != null) {
        Object exArgs[] = { algorithmURI, transformSpi };
        throw new AlgorithmAlreadyRegisteredException("algorithm.alreadyRegistered", exArgs);
    }
    transformSpiHash.put(algorithmURI, implementingClass);
}
 

/**
 * Registers a ResourceResolverSpi class at the beginning of the provider
 * list. This method logs a warning if the class cannot be registered.
 *
 * @param className the name of the ResourceResolverSpi class to be registered
 * @throws SecurityException if a security manager is installed and the
 *    caller does not have permission to register a resource resolver
 */
@SuppressWarnings("unchecked")
public static void registerAtStart(String className) {
    JavaUtils.checkRegisterPermission();
    try {
        Class<ResourceResolverSpi> resourceResolverClass =
            (Class<ResourceResolverSpi>) Class.forName(className);
        register(resourceResolverClass, true);
    } catch (ClassNotFoundException e) {
        log.log(java.util.logging.Level.WARNING, "Error loading resolver " + className + " disabling it");
    }
}
 

private byte[] getBytesFromInputStream() throws IOException {
    if (bytes != null) {
        return bytes;
    }
    if (inputOctetStreamProxy == null) {
        return null;
    }
    try {
        bytes = JavaUtils.getBytesFromStream(inputOctetStreamProxy);
    } finally {
        inputOctetStreamProxy.close();
    }
    return bytes;
}
 

/**
 * Registers a ResourceResolverSpi class. This method logs a warning if
 * the class cannot be registered.
 *
 * @param className the name of the ResourceResolverSpi class to be registered
 * @throws SecurityException if a security manager is installed and the
 *    caller does not have permission to register a resource resolver
 */
@SuppressWarnings("unchecked")
public static void register(String className) {
    JavaUtils.checkRegisterPermission();
    try {
        Class<ResourceResolverSpi> resourceResolverClass =
            (Class<ResourceResolverSpi>) Class.forName(className);
        register(resourceResolverClass, false);
    } catch (ClassNotFoundException e) {
        log.log(java.util.logging.Level.WARNING, "Error loading resolver " + className + " disabling it");
    }
}
 

/**
 * Method register
 *
 * @param algorithmURI
 * @param implementingClass
 * @throws AlgorithmAlreadyRegisteredException
 * @throws SecurityException if a security manager is installed and the
 *    caller does not have permission to register the canonicalizer
 */
public static void register(String algorithmURI, Class<? extends CanonicalizerSpi> implementingClass)
    throws AlgorithmAlreadyRegisteredException, ClassNotFoundException {
    JavaUtils.checkRegisterPermission();
    // check whether URI is already registered
    Class<? extends CanonicalizerSpi> registeredClass = canonicalizerHash.get(algorithmURI);

    if (registeredClass != null)  {
        Object exArgs[] = { algorithmURI, registeredClass };
        throw new AlgorithmAlreadyRegisteredException("algorithm.alreadyRegistered", exArgs);
    }

    canonicalizerHash.put(algorithmURI, implementingClass);
}
 

private byte[] getBytesFromInputStream() throws IOException {
    if (bytes != null) {
        return bytes;
    }
    if (inputOctetStreamProxy == null) {
        return null;
    }
    try {
        bytes = JavaUtils.getBytesFromStream(inputOctetStreamProxy);
    } finally {
        inputOctetStreamProxy.close();
    }
    return bytes;
}
 

private byte[] getBytesFromInputStream() throws IOException {
    if (bytes != null) {
        return bytes;
    }
    if (inputOctetStreamProxy == null) {
        return null;
    }
    try {
        bytes = JavaUtils.getBytesFromStream(inputOctetStreamProxy);
    } finally {
        inputOctetStreamProxy.close();
    }
    return bytes;
}