import org.jdom2.transform.JDOMSource; //导入依赖的package包/类
@Override
public Source resolve(String href, String base) throws TransformerException {
    String id = href.substring(href.indexOf(":") + 1);
    LOGGER.debug("Reading METS for ID {}", id);
    MCRObjectID objId = MCRObjectID.getInstance(id);
    if (!objId.getTypeId().equals("derivate")) {
        String derivateID = getDerivateFromObject(id);
        if (derivateID == null) {
            return new JDOMSource(new Element("mets", Namespace.getNamespace("mets", "http://www.loc.gov/METS/")));
        }
        id = derivateID;
    }
    MCRPath metsPath = MCRPath.getPath(id, "/mets.xml");
    try {
        if (Files.exists(metsPath)) {
            //TODO: generate new METS Output
            //ignoreNodes.add(metsFile);
            return new MCRPathContent(metsPath).getSource();
        }
        Document mets = MCRMETSGeneratorFactory.create(MCRPath.getPath(id, "/")).generate().asDocument();
        return new JDOMSource(mets);
    } catch (Exception e) {
        throw new TransformerException(e);
    }
}
 

import org.jdom2.transform.JDOMSource; //导入依赖的package包/类
@Override
public Source resolve(String href, String base) throws TransformerException {
    String type = href.substring(href.indexOf(":") + 1);
    String path = "/templates/" + type + "/";
    LOGGER.debug("Reading templates from {}", path);
    Set<String> resourcePaths = context.getResourcePaths(path);
    ArrayList<String> templates = new ArrayList<>();
    if (resourcePaths != null) {
        for (String resourcePath : resourcePaths) {
            if (!resourcePath.endsWith("/")) {
                //only handle directories
                continue;
            }
            String templateName = resourcePath.substring(path.length(), resourcePath.length() - 1);
            LOGGER.debug("Checking if template: {}", templateName);
            if (templateName.contains("/")) {
                continue;
            }
            templates.add(templateName);
        }
        Collections.sort(templates);
    }
    LOGGER.info("Found theses templates: {}", templates);
    return new JDOMSource(getStylesheets(templates));
}
 

import org.jdom2.transform.JDOMSource; //导入依赖的package包/类
/**
 * validates <code>doc</code> using XML Schema defined <code>schemaURI</code>
 * @param doc document to be validated
 * @param schemaURI URI of XML Schema document
 * @throws SAXException if validation fails
 * @throws IOException if resolving resources fails
 */
public static void validate(Document doc, String schemaURI) throws SAXException, IOException {
    SchemaFactory sf = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
    sf.setResourceResolver(MCREntityResolver.instance());
    Schema schema;
    try {
        schema = sf.newSchema(MCRURIResolver.instance().resolve(schemaURI, null));
    } catch (TransformerException e) {
        Throwable cause = e.getCause();
        if (cause == null) {
            throw new IOException(e);
        }
        if (cause instanceof SAXException) {
            throw (SAXException) cause;
        }
        if (cause instanceof IOException) {
            throw (IOException) cause;
        }
        throw new IOException(e);
    }
    Validator validator = schema.newValidator();
    validator.setResourceResolver(MCREntityResolver.instance());
    validator.validate(new JDOMSource(doc));
}
 

import org.jdom2.transform.JDOMSource; //导入依赖的package包/类
/**
 *   This routine is sued to generate files that have no .xml file, but only a .xsl file.
 *   It is used for files included by other html files to avoid repreating the contents;
 *     - header.html
 *     - generated.html
 */
public static void generateIncludedHtml(Document document, File outputPath, String xslname) throws IOException {
  if (ConfigurationManager.getCurrentProfile().getGenerateHtml()) {
    FileOutputStream fos = null;
    try {
      JDOMSource source = new JDOMSource(document);
      File htmlFile = new File(outputPath,getHtmlFilename(xslname));
      fos = new FileOutputStream(htmlFile);
      StreamResult streamResult = new StreamResult(fos);
      try {
        Transformer transformer;
        transformer = JDOMManager.getIncludeTransformer(xslname);
        transformer.transform(source, streamResult);
      } catch (TransformerException e) {
        logger.error(Localization.Main.getText("error.cannotTransform", xslname), e);
      }
    } finally {
      if (fos != null)
        fos.close();
    }
  }
}
 

import org.jdom2.transform.JDOMSource; //导入依赖的package包/类
@Override
public Source resolve(String href, String base) throws TransformerException {
    href = href.substring(href.indexOf(":") + 1);
    Element mods = MCRURIResolver.instance().resolve(href);
    MCRMODSSorter.sort(mods);
    return new JDOMSource(mods);
}
 

import org.jdom2.transform.JDOMSource; //导入依赖的package包/类
@Override
public Source resolve(String href, String base) throws TransformerException {
    href = href.substring(href.indexOf(":") + 1);
    String configID = href.substring(0, href.indexOf(':'));

    href = href.substring(href.indexOf(":") + 1);
    Element mods = MCRURIResolver.instance().resolve(href);

    enrichPublication(mods, configID);

    return new JDOMSource(mods);
}
 

import org.jdom2.transform.JDOMSource; //导入依赖的package包/类
@Override
public Source resolve(final String href, final String base) throws TransformerException {
    String realmID = href.split(":")[1];
    if ("all".equals(realmID)) {
        return MCRRealmFactory.getRealmsSource();
    } else if ("local".equals(realmID)) {
        realmID = MCRRealmFactory.getLocalRealm().getID();
    }
    return new JDOMSource(getElement(MCRRealmFactory.getRealm(realmID).getID()));
}
 

import org.jdom2.transform.JDOMSource; //导入依赖的package包/类
@Override
public Source resolve(final String href, final String base) throws TransformerException {
    final String target = href.substring(href.indexOf(":") + 1);
    final String[] part = target.split(":");
    final String method = part[0];
    try {
        if ("getAssignableGroupsForUser".equals(method)) {
            return new JDOMSource(getAssignableGroupsForUser());
        }
    } catch (final MCRAccessException exc) {
        throw new TransformerException(exc);
    }
    throw new TransformerException(new IllegalArgumentException("Unknown method " + method + " in uri " + href));
}
 

import org.jdom2.transform.JDOMSource; //导入依赖的package包/类
/**
 * Builds an MCRUser instance from the given element.
 * @param element as generated by {@link #buildExportableXML(MCRUser)}. 
 */
public static MCRUser buildMCRUser(Element element) {
    if (!element.getName().equals(USER_ELEMENT_NAME)) {
        throw new IllegalArgumentException("Element is not a mycore user element.");
    }
    try {
        Unmarshaller unmarshaller = JAXB_CONTEXT.createUnmarshaller();
        return (MCRUser) unmarshaller.unmarshal(new JDOMSource(element));
    } catch (JAXBException e) {
        throw new MCRException("Exception while transforming Element to MCRUser.", e);
    }
}
 

import org.jdom2.transform.JDOMSource; //导入依赖的package包/类
/**
 * Builds an MCRRole instance from the given element.
 * @param element as generated by {@link #buildExportableXML(MCRRole)}. 
 */
public static MCRRole buildMCRRole(Element element) {
    if (!element.getName().equals(ROLE_ELEMENT_NAME)) {
        throw new IllegalArgumentException("Element is not a mycore role element.");
    }
    try {
        Unmarshaller unmarshaller = JAXB_CONTEXT.createUnmarshaller();
        return (MCRRole) unmarshaller.unmarshal(new JDOMSource(element));
    } catch (JAXBException e) {
        throw new MCRException("Exception while transforming Element to MCRUser.", e);
    }
}
 

import org.jdom2.transform.JDOMSource; //导入依赖的package包/类
public static MCRUserAttributeMapper instance(Element attributeMapping) {
    try {
        JAXBContext jaxb = JAXBContext.newInstance(Mappings.class.getPackage().getName(),
            Mappings.class.getClassLoader());

        Unmarshaller unmarshaller = jaxb.createUnmarshaller();
        Mappings mappings = (Mappings) unmarshaller.unmarshal(new JDOMSource(attributeMapping));

        MCRUserAttributeMapper uam = new MCRUserAttributeMapper();
        uam.attributeMapping.putAll(mappings.getAttributeMap());
        return uam;
    } catch (Exception e) {
        return null;
    }
}
 

import org.jdom2.transform.JDOMSource; //导入依赖的package包/类
public Source resolve(String href, String base) throws TransformerException {
    try {
        String code = href.split(":")[1];
        MCRLanguage language = MCRLanguageFactory.instance().getLanguage(code);
        Document doc = new Document(buildXML(language));
        return new JDOMSource(doc);
    } catch (Exception ex) {
        throw new TransformerException(ex);
    }
}
 

import org.jdom2.transform.JDOMSource; //导入依赖的package包/类
/**
 * Parse a email from given {@link Element}.
 * 
 * @param xml the email
 * @return the {@link EMail} object
 */
public static EMail parseXML(final Element xml) {
    try {
        final Unmarshaller unmarshaller = JAXB_CONTEXT.createUnmarshaller();
        return (EMail) unmarshaller.unmarshal(new JDOMSource(xml));
    } catch (final JAXBException e) {
        throw new MCRException("Exception while transforming Element to EMail.", e);
    }
}
 

import org.jdom2.transform.JDOMSource; //导入依赖的package包/类
private Source getSource(MCRStoredMetadata retrieve) throws IOException {
    Element e = new Element("versions");
    Element v = new Element("version");
    e.addContent(v);
    v.setAttribute("date", MCRXMLFunctions.getISODate(retrieve.getLastModified(), null));
    return new JDOMSource(e);
}
 

import org.jdom2.transform.JDOMSource; //导入依赖的package包/类
public static String xmlOutputter(Document doc, String xslt, HashMap<String,String> params) throws IOException {

        String result = null;

        try {

            Processor processor = new Processor(false);

            XdmNode source = processor.newDocumentBuilder().build(new JDOMSource( doc ));
            Serializer out = new Serializer();
            out.setOutputProperty(Serializer.Property.METHOD, "xml");
            out.setOutputProperty(Serializer.Property.INDENT, "yes");

            StringWriter buffer = new StringWriter();
            out.setOutputWriter(new PrintWriter( buffer ));

            XsltCompiler xsltCompiler = processor.newXsltCompiler();
            XsltExecutable exp = xsltCompiler.compile(new StreamSource(xslt));
            XsltTransformer trans = exp.load();
            trans.setInitialContextNode(source);
            trans.setDestination(out);

            if (params != null) {
                for (String p : params.keySet()) {
                    trans.setParameter(new QName(p), new XdmAtomicValue(params.get(p)));
                }
            }

            trans.transform();

            result = buffer.toString();

        } catch (SaxonApiException e) {

            e.printStackTrace();
        }

        return result;
    }
 

import org.jdom2.transform.JDOMSource; //导入依赖的package包/类
@Test
public void test() throws Exception {
	
	WebServiceTemplate template = new WebServiceTemplate();
	
	SaajSoapMessageFactory messageFactory = new SaajSoapMessageFactory();
	messageFactory.setSoapVersion(SoapVersion.SOAP_12);
	messageFactory.afterPropertiesSet();
	template.setMessageFactory(messageFactory);
	
	CryptoFactoryBean cryptoFactory = new CryptoFactoryBean();
	cryptoFactory.setKeyStoreLocation(new ClassPathResource("keystore.jks"));
	cryptoFactory.setKeyStorePassword("password");
	cryptoFactory.afterPropertiesSet();
	Crypto crypto = cryptoFactory.getObject();
	
	SAML2CallbackHandler samlCallbackHandler = new SAML2CallbackHandler(crypto, "selfsigned");
	
	SAMLIssuerImpl issuer = new SAMLIssuerImpl();
	issuer.setIssuerCrypto(crypto);
	issuer.setIssuerKeyName("selfsigned");
	issuer.setIssuerKeyPassword("password");
	issuer.setIssuerName("selfsigned");
	issuer.setSendKeyValue(false);
	issuer.setSignAssertion(true);
	issuer.setCallbackHandler(samlCallbackHandler);
	
	Wss4jSecurityInterceptor securityInterceptor = new Wss4jSecurityInterceptor();
	securityInterceptor.setSecurementActions("Timestamp SAMLTokenSigned");
	securityInterceptor.setSecurementSignatureCrypto(crypto);
	securityInterceptor.setSecurementUsername("selfsigned");
	securityInterceptor.setSecurementPassword("password");
	securityInterceptor.setSamlIssuer(issuer);
	securityInterceptor.afterPropertiesSet();
	
	template.setInterceptors(new ClientInterceptor[] {securityInterceptor});
	template.afterPropertiesSet();
	
	Element hello = new Element("Hello", "urn:jaminh:example");
	template.sendSourceAndReceiveToResult("http://localhost:8080/spring-saml-example-war", new JDOMSource(hello), new JDOMResult());
	template.sendSourceAndReceiveToResult("http://localhost:8080/spring-saml-example-war", new JDOMSource(hello), new JDOMResult());
	template.sendSourceAndReceiveToResult("http://localhost:8080/spring-saml-example-war", new JDOMSource(hello), new JDOMResult());
	
}
 

import org.jdom2.transform.JDOMSource; //导入依赖的package包/类
@Override
public void doWithMessage(WebServiceMessage message) throws IOException,
    TransformerException {
  sessionHolder.addSessionIdToSoapMessage((SoapMessage) message);
  transformer.transform(new JDOMSource(request), 
      message.getPayloadResult());
  
}
 

import org.jdom2.transform.JDOMSource; //导入依赖的package包/类
/**
 * Returns the Realms JDOM document as a {@link Source} useful for transformation processes.
 */
static Source getRealmsSource() {
    reInitIfNeeded();
    return new JDOMSource(realmsDocument);
}
 

import org.jdom2.transform.JDOMSource; //导入依赖的package包/类
/**
 * The method read a MCRObject and use the transformer to write the data to a file. They are any steps to handel
 * errors and save the damaged data.
 * <ul>
 * <li>Read data for object ID in the MCRObject, add ACL's and store it as checked and transformed XML. Return true.
 * </li>
 * <li>If it can't find a transformer instance (no script file found) it store the checked data with ACL's native in
 * the file. Warning and return true.</li>
 * <li>If it get an exception while build the MCRObject, it try to read the XML blob and stor it without check and
 * ACL's to the file. Warning and return true.</li>
 * <li>If it get an exception while store the native data without check, ACÖ's and transformation it return a
 * warning and false.</li>
 * </ul>
 *
 * @param dir
 *            the file instance to store
 * @param trans
 *            the XML transformer
 * @param nid
 *            the MCRObjectID
 * @return true if the store was okay (see description), else return false
 * @throws TransformerException
 * @throws IOException
 * @throws MCRException
 * @throws SAXParseException
 */
private static boolean exportMCRObject(File dir, Transformer trans, String nid)
    throws TransformerException, IOException, MCRException, SAXParseException {
    MCRContent content;
    try {
        // if object do'snt exist - no exception is catched!
        content = MCRXMLMetadataManager.instance().retrieveContent(MCRObjectID.getInstance(nid));
    } catch (MCRException ex) {
        return false;
    }

    File xmlOutput = new File(dir, nid + ".xml");

    if (trans != null) {
        FileOutputStream out = new FileOutputStream(xmlOutput);
        StreamResult sr = new StreamResult(out);
        Document doc = MCRXMLParserFactory.getNonValidatingParser().parseXML(content);
        trans.transform(new org.jdom2.transform.JDOMSource(doc), sr);
    } else {
        content.sendTo(xmlOutput);
    }
    LOGGER.info("Object {} saved to {}.", nid, xmlOutput.getCanonicalPath());
    return true;
}
 

import org.jdom2.transform.JDOMSource; //导入依赖的package包/类
private static void xslt(String objectId, String xslFilePath, boolean force) throws IOException, JDOMException, SAXException,
        URISyntaxException, TransformerException, MCRPersistenceException, MCRAccessException {
    File xslFile = new File(xslFilePath);
    URL xslURL;
    if (!xslFile.exists()) {
        try {
            xslURL = new URL(xslFilePath);
        } catch (MalformedURLException e) {
            LOGGER.error("XSL parameter is not a file or URL: {}", xslFilePath);
            return;
        }
    } else {
        xslURL = xslFile.toURI().toURL();
    }
    MCRObjectID mcrId = MCRObjectID.getInstance(objectId);
    Document document = MCRXMLMetadataManager.instance().retrieveXML(mcrId);
    // do XSL transform
    TransformerFactory transformerFactory = TransformerFactory.newInstance();
    transformerFactory.setErrorListener(MCRErrorListener.getInstance());
    transformerFactory.setURIResolver(MCRURIResolver.instance());
    XMLReader xmlReader = XMLReaderFactory.createXMLReader();
    xmlReader.setEntityResolver(MCREntityResolver.instance());
    SAXSource styleSource = new SAXSource(xmlReader, new InputSource(xslURL.toURI().toString()));
    Transformer transformer = transformerFactory.newTransformer(styleSource);
    for (Entry<String, String> property : MCRConfiguration.instance().getPropertiesMap().entrySet()) {
        transformer.setParameter(property.getKey(), property.getValue());
    }
    transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
    transformer.setOutputProperty(OutputKeys.INDENT, "no");
    JDOMResult result = new JDOMResult();
    transformer.transform(new JDOMSource(document), result);
    Document resultDocument = Objects.requireNonNull(result.getDocument(), "Could not get transformation result");

    String originalName = document.getRootElement().getName();
    String resultName = resultDocument.getRootElement().getName();
    if (!force && !originalName.equals(resultName)) {
        LOGGER.error("{}: root name '{}' does not match result name '{}'.", objectId, originalName, resultName);
        return;
    }

    // update on diff
    if (MCRXMLHelper.deepEqual(document, resultDocument)) {
        return;
    }
    if(resultName.equals(MCRObject.ROOT_NAME)) {
        MCRMetadataManager.update(new MCRObject(resultDocument));
    } else if(resultName.equals(MCRDerivate.ROOT_NAME)) {
        MCRMetadataManager.update(new MCRDerivate(resultDocument));
    } else {
        LOGGER.error("Unable to transform '{}' because unknown result root name '{}'.", objectId, resultName);
    }
}