import org.opensaml.xml.XMLObjectBuilder; //导入依赖的package包/类
/**
 * Constructs the XMLObject that the given DOM Element will be unmarshalled into. If the DOM element has an XML
 * Schema type defined this method will attempt to retrieve an XMLObjectBuilder, from the factory given at
 * construction time, using the schema type. If no schema type is present or no builder is registered with the
 * factory for the schema type, the elements QName is used. Once the builder is found the XMLObject is create by
 * invoking {@link XMLObjectBuilder#buildObject(String, String, String)}. Extending classes may wish to override
 * this logic if more than just schema type or element name (e.g. element attributes or content) need to be used to
 * determine which XMLObjectBuilder should be used to create the XMLObject.
 * 
 * @param domElement the DOM Element the created XMLObject will represent
 * 
 * @return the empty XMLObject that DOM Element can be unmarshalled into
 * 
 * @throws UnmarshallingException thrown if there is now XMLObjectBuilder registered for the given DOM Element
 */
protected XMLObject buildXMLObject(Element domElement) throws UnmarshallingException {
    if (log.isTraceEnabled()) {
        log.trace("Building XMLObject for {}", XMLHelper.getNodeQName(domElement));
    }
    XMLObjectBuilder xmlObjectBuilder;

    xmlObjectBuilder = xmlObjectBuilderFactory.getBuilder(domElement);
    if (xmlObjectBuilder == null) {
        xmlObjectBuilder = xmlObjectBuilderFactory.getBuilder(Configuration.getDefaultProviderQName());
        if (xmlObjectBuilder == null) {
            String errorMsg = "Unable to locate builder for " + XMLHelper.getNodeQName(domElement);
            log.error(errorMsg);
            throw new UnmarshallingException(errorMsg);
        } else {
            if (log.isTraceEnabled()) {
                log.trace("No builder was registered for {} but the default builder {} was available, using it.",
                        XMLHelper.getNodeQName(domElement), xmlObjectBuilder.getClass().getName());
            }
        }
    }

    return xmlObjectBuilder.buildObject(domElement);
}
 

import org.opensaml.xml.XMLObjectBuilder; //导入依赖的package包/类
/**
 * Utility method for creating an OpenSAML object given its type and assigns the value.
 * 
 * @param clazz
 *          the class to create
 * @param value
 *          the string value to assign
 * @return the XML object or {@code null} if value is {@code null}
 */
private <T extends XSString> T createXSString(Class<T> clazz, String value) {
  if (value == null) {
    return null;
  }
  QName elementName = null;
  String localName = null;
  try {
    elementName = (QName) clazz.getDeclaredField("DEFAULT_ELEMENT_NAME").get(null);
    localName = (String) clazz.getDeclaredField("DEFAULT_ELEMENT_LOCAL_NAME").get(null);
  }
  catch (NoSuchFieldException | IllegalArgumentException | IllegalAccessException | SecurityException e) {
    throw new RuntimeException(e);
  }
  XMLObjectBuilder<?> builder = Configuration.getBuilderFactory().getBuilder(elementName);
  XMLObject object = builder.buildObject(new QName(this.getElementQName().getNamespaceURI(), localName, this.getElementQName().getPrefix()));
  T xsstring = clazz.cast(object);
  xsstring.setValue(value);
  return xsstring;
}
 

import org.opensaml.xml.XMLObjectBuilder; //导入依赖的package包/类
private static AttributeStatement createAttributeStatement() {

		AttributeStatement attributeStatement = create(AttributeStatement.DEFAULT_ELEMENT_NAME);

		for (AttributeData attributeData : samlResponseData.getAttributes()) {
			Attribute attribute = create(Attribute.DEFAULT_ELEMENT_NAME);
			attribute.setFriendlyName(attributeData.getFriendlyName());
			attribute.setName(attributeData.getName());
			attribute.setNameFormat(attributeData.getNameFormat());

			XMLObjectBuilder<XSAny> builder = getXMLObjectBuilder(XSAny.TYPE_NAME);

			for (String values : attributeData.getValue().split(";", -1)) {
				XSAny value = builder
						.buildObject(AttributeValue.DEFAULT_ELEMENT_NAME);

				value.setTextContent(values);

				attribute.getAttributeValues().add(value);
			}

			attributeStatement.getAttributes().add(attribute);
		}
		return attributeStatement;
	}
 

import org.opensaml.xml.XMLObjectBuilder; //导入依赖的package包/类
/**
 * Create XMLObject from a given QName
 *
 * @param objectQName: QName of the object to be built into a XMLObject
 * @return built xmlObject
 * @throws EntitlementException
 */
private static XMLObject buildXMLObject(QName objectQName) throws EntitlementException {

    XMLObjectBuilder builder = org.opensaml.xml.Configuration.getBuilderFactory().getBuilder(objectQName);
    if (builder == null) {
        throw new EntitlementException("Unable to retrieve builder for object QName "
                + objectQName);
    }
    return builder.buildObject(objectQName.getNamespaceURI(), objectQName.getLocalPart(),
            objectQName.getPrefix());
}
 

import org.opensaml.xml.XMLObjectBuilder; //导入依赖的package包/类
/**
 * Builds SAML Elements
 *
 * @param objectQName
 * @return
 * @throws SSOAgentException
 */
private static XMLObject buildXMLObject(QName objectQName) throws SSOAgentException {
    doBootstrap();
    XMLObjectBuilder builder =
            org.opensaml.xml.Configuration.getBuilderFactory()
                    .getBuilder(objectQName);
    if (builder == null) {
        throw new SSOAgentException("Unable to retrieve builder for object QName " +
                objectQName);
    }
    return builder.buildObject(objectQName.getNamespaceURI(), objectQName.getLocalPart(),
            objectQName.getPrefix());
}
 

import org.opensaml.xml.XMLObjectBuilder; //导入依赖的package包/类
/**
 * Utility method for creating an OpenSAML object given its element name.
 * 
 * @param clazz
 *          the class to create
 * @param elementName
 *          the element name for the XML object to create
 * @return the XML object
 */
public static <T extends XMLObject> T createSamlObject(Class<T> clazz, QName elementName) {
  if (!XMLObject.class.isAssignableFrom(clazz)) {
    throw new RuntimeException(String.format("%s is not a XMLObject class", clazz.getName()));
  }
  XMLObjectBuilderFactory builderFactory = Configuration.getBuilderFactory();
  XMLObjectBuilder<?> builder = builderFactory.getBuilder(elementName);
  if (builder == null) {
    // No builder registered for the given element name. Try creating a builder for the default element name.
    builder = builderFactory.getBuilder(getDefaultElementName(clazz));
  }
  Object object = builder.buildObject(elementName);
  return clazz.cast(object);
}
 

import org.opensaml.xml.XMLObjectBuilder; //导入依赖的package包/类
/**
 * Test creating and marshalling/unmarshalling an attribute with a name represented in two ways.
 * 
 * @throws Exception
 *           for errors
 */
@Test
public void testTransliteratedAttribute() throws Exception {
  Attribute attribute = OpenSAMLTestBase.createSamlObject(Attribute.class, Attribute.DEFAULT_ELEMENT_NAME);
  attribute.setName(AttributeConstants.EIDAS_CURRENT_FAMILY_NAME_ATTRIBUTE_NAME);
  attribute.setNameFormat(Attribute.URI_REFERENCE);

  XMLObjectBuilder<CurrentFamilyNameType> builder = OpenSAMLTestBase.getBuilder(CurrentFamilyNameType.TYPE_NAME);

  CurrentFamilyNameType name1 = builder.buildObject(AttributeValue.DEFAULT_ELEMENT_NAME, CurrentFamilyNameType.TYPE_NAME);
  name1.setValue("Onasis");

  CurrentFamilyNameType name2 = builder.buildObject(AttributeValue.DEFAULT_ELEMENT_NAME, CurrentFamilyNameType.TYPE_NAME);
  name2.setValue("Ωνασης");
  name2.setLatinScript(false);

  attribute.getAttributeValues().add(name1);
  attribute.getAttributeValues().add(name2);

  Element xml = OpenSAMLTestBase.marshall(attribute);

  Attribute attribute2 = OpenSAMLTestBase.unmarshall(xml, Attribute.class);
  Assert.assertEquals(((CurrentFamilyNameType) attribute.getAttributeValues().get(0)).getValue(), ((CurrentFamilyNameType) attribute2
    .getAttributeValues().get(0)).getValue());
  Assert.assertEquals(((CurrentFamilyNameType) attribute.getAttributeValues().get(1)).getValue(), ((CurrentFamilyNameType) attribute2
    .getAttributeValues().get(1)).getValue());

  // Unmarshall again, but this time from the XML string ...
  String xmlString = XMLHelper.prettyPrintXML(xml);

  Attribute attribute3 = (Attribute) OpenSAMLTestBase.unmarshallFromInputStream(Configuration.getParserPool(),
    new ByteArrayInputStream(xmlString.getBytes("UTF-8")));
  Assert.assertEquals(((CurrentFamilyNameType) attribute.getAttributeValues().get(0)).getValue(), ((CurrentFamilyNameType) attribute3
    .getAttributeValues().get(0)).getValue());
  Assert.assertEquals(((CurrentFamilyNameType) attribute.getAttributeValues().get(1)).getValue(), ((CurrentFamilyNameType) attribute3
    .getAttributeValues().get(1)).getValue());
}
 

import org.opensaml.xml.XMLObjectBuilder; //导入依赖的package包/类
/**
 * Test that creates an attribute and places a CurrentAddessType as a value.
 * 
 * @throws Exception
 *           for errors
 */
@Test
public void testAttributeCreate() throws Exception {

  Attribute attribute = OpenSAMLTestBase.createSamlObject(Attribute.class, Attribute.DEFAULT_ELEMENT_NAME);
  attribute.getNamespaceManager().registerNamespaceDeclaration(new Namespace(EidasConstants.EIDAS_NP_NS, "eidas"));
  attribute.setName(AttributeConstants.EIDAS_CURRENT_ADDRESS_ATTRIBUTE_NAME);
  attribute.setFriendlyName(AttributeConstants.EIDAS_CURRENT_ADDRESS_ATTRIBUTE_FRIENDLY_NAME);
  attribute.setNameFormat(Attribute.URI_REFERENCE);

  XMLObjectBuilder<CurrentAddressType> builder = OpenSAMLTestBase.getBuilder(CurrentAddressType.TYPE_NAME);
  CurrentAddressType address = builder.buildObject(AttributeValue.DEFAULT_ELEMENT_NAME, 
    new QName(EidasConstants.EIDAS_NP_NS, CurrentAddressType.TYPE_NAME.getLocalPart(), "eidas"));
  fill(address);

  attribute.getAttributeValues().add(address);

  Element attrElement = OpenSAMLTestBase.marshall(attribute);

  System.out.println(XMLHelper.prettyPrintXML(attrElement));

  // Make sure we inserted the correct namespace prefix while marshalling the CurrentAddressType
  Assert.assertTrue((new String(Base64.decode(attrElement.getFirstChild().getFirstChild().getNodeValue()))).startsWith("<eidas:"));

  // Unmarshall
  Attribute attribute2 = OpenSAMLTestBase.unmarshall(attrElement, Attribute.class);

  Assert.assertNotNull(attribute2);
  Assert.assertEquals(AttributeConstants.EIDAS_CURRENT_ADDRESS_ATTRIBUTE_NAME, attribute2.getName());
  Assert.assertEquals(AttributeConstants.EIDAS_CURRENT_ADDRESS_ATTRIBUTE_FRIENDLY_NAME, attribute2.getFriendlyName());

  List<XMLObject> values = attribute.getAttributeValues();
  Assert.assertTrue(values.size() == 1);
  Assert.assertTrue(values.get(0) instanceof CurrentAddressType);
  CurrentAddressType address2 = (CurrentAddressType) values.get(0);
  verify(address, address2);
}
 

import org.opensaml.xml.XMLObjectBuilder; //导入依赖的package包/类
/**
 * Build a new empty object of the requested type.
 * 
 * The requested type must have a DEFAULT_ELEMENT_NAME attribute describing the element type as a QName.
 * 
 * @param <T> SAML Object type
 */
@SuppressWarnings("unchecked")
public static <T extends XMLObject> T buildXMLObject(Class<T> type) {
	try {
		QName objectQName = getElementQName(type);
		XMLObjectBuilder<T> builder = Configuration.getBuilderFactory().getBuilder(objectQName);
		if (builder == null) {
			throw new InvalidParameterException("No builder exists for object: " + objectQName.getLocalPart());
		}
		return builder.buildObject(objectQName.getNamespaceURI(), objectQName.getLocalPart(), objectQName.getPrefix());
	} catch (SecurityException e) {
		throw new RuntimeException(e);
	}				
}
 

import org.opensaml.xml.XMLObjectBuilder; //导入依赖的package包/类
/**
 * Builds SAML Objects for a given QName
 *
 * @param pQName Element QName for the SAML Object
 * @return SAML Object
 */
private static XMLObject buildXMLObject(QName pQName) {
  XMLObjectBuilder lObjectBuilder = org.opensaml.xml.Configuration.getBuilderFactory().getBuilder(pQName);

  if (lObjectBuilder == null) {
    throw new ExInternal("Cannot get builder for QName: " + pQName);
  }

  return lObjectBuilder.buildObject(pQName.getNamespaceURI(), pQName.getLocalPart(), pQName.getPrefix());
}
 

import org.opensaml.xml.XMLObjectBuilder; //导入依赖的package包/类
protected static XMLObject buildXMLObject(QName objectQName) throws IdentityProviderException {
    XMLObjectBuilder builder = Configuration.getBuilderFactory().getBuilder(objectQName);
    if (builder == null) {
        throw new IdentityProviderException("Unable to retrieve builder for object QName " + objectQName);
    }
    return builder.buildObject(objectQName.getNamespaceURI(), objectQName.getLocalPart(), objectQName.getPrefix());
}
 

import org.opensaml.xml.XMLObjectBuilder; //导入依赖的package包/类
/**
 * Builds SAML Elements
 *
 * @param objectQName
 * @return
 * @throws SAMLSSOException
 */
private static XMLObject buildXMLObject(QName objectQName) throws SAMLSSOException {
    XMLObjectBuilder builder =
            org.opensaml.xml.Configuration.getBuilderFactory()
                    .getBuilder(objectQName);
    if (builder == null) {
        throw new SAMLSSOException("Unable to retrieve builder for object QName " +
                objectQName);
    }
    return builder.buildObject(objectQName.getNamespaceURI(), objectQName.getLocalPart(),
            objectQName.getPrefix());
}
 

import org.opensaml.xml.XMLObjectBuilder; //导入依赖的package包/类
public static XMLObject buildXMLObject(QName objectQName) throws Exception {

        XMLObjectBuilder builder = org.opensaml.xml.Configuration.getBuilderFactory().getBuilder(
                objectQName);
        if (builder == null) {
            throw new Exception("Unable to retrieve builder for object QName " + objectQName);
        }
        return builder.buildObject(objectQName.getNamespaceURI(), objectQName.getLocalPart(),
                objectQName.getPrefix());
    }
 

import org.opensaml.xml.XMLObjectBuilder; //导入依赖的package包/类
/**
 * Builds SAML Elements
 *
 * @param objectQName
 * @return
 * @throws IdentityException
 */
private XMLObject buildXMLObject(QName objectQName) throws IdentityException {
    XMLObjectBuilder builder =
            org.opensaml.xml.Configuration.getBuilderFactory()
                    .getBuilder(objectQName);
    if (builder == null) {
        throw IdentityException.error("Unable to retrieve builder for object QName " +
                                    objectQName);
    }
    return builder.buildObject(objectQName.getNamespaceURI(), objectQName.getLocalPart(),
                               objectQName.getPrefix());
}
 

import org.opensaml.xml.XMLObjectBuilder; //导入依赖的package包/类
/**
 * Create XMLObject from a given QName
 *
 * @param objectQName: QName of the object to be built into a XMLObject
 * @return built xmlObject
 * @throws EntitlementProxyException
 */
private XMLObject buildXMLObject(QName objectQName) throws EntitlementProxyException {

    XMLObjectBuilder builder = org.opensaml.xml.Configuration.getBuilderFactory().getBuilder(objectQName);
    if (builder == null) {
        throw new EntitlementProxyException("Unable to retrieve builder for object QName "
                + objectQName);
    }
    return builder.buildObject(objectQName.getNamespaceURI(), objectQName.getLocalPart(),
            objectQName.getPrefix());
}
 

import org.opensaml.xml.XMLObjectBuilder; //导入依赖的package包/类
/**
 * Signs the given metadata document root.
 * 
 * @param metadata metadata document
 * @param signingCredential credential used to sign the document
 */
private static void sign(SignableSAMLObject metadata, Credential signingCredential) {
    XMLObjectBuilder<Signature> sigBuilder = Configuration.getBuilderFactory().getBuilder(
            Signature.DEFAULT_ELEMENT_NAME);
    Signature signature = sigBuilder.buildObject(Signature.DEFAULT_ELEMENT_NAME);
    signature.setSigningCredential(signingCredential);
    metadata.setSignature(signature);

    try {
        Signer.signObject(signature);
    } catch (SignatureException e) {
        log.error("Error when attempting to sign object", e);
        System.exit(1);
    }
}
 

import org.opensaml.xml.XMLObjectBuilder; //导入依赖的package包/类
/**
 * Builds the requested XMLObject.
 * 
 * @param objectQName name of the XMLObject
 * 
 * @return the build XMLObject
 */
public XMLObject buildXMLObject(QName objectQName){
    XMLObjectBuilder builder = Configuration.getBuilderFactory().getBuilder(objectQName);
    if(builder == null){
        fail("Unable to retrieve builder for object QName " + objectQName);
    }
    return builder.buildObject(objectQName.getNamespaceURI(), objectQName.getLocalPart(), objectQName.getPrefix());
}
 

import org.opensaml.xml.XMLObjectBuilder; //导入依赖的package包/类
public static <T extends XMLObject> T buildXMLObject(Class<T> clazz, QName objectQName) {
	XMLObjectBuilder<T> builder = Configuration.getBuilderFactory().getBuilder(objectQName);
	if (builder == null) {
		throw new RuntimeException("Unable to retrieve builder for object QName " + objectQName);
	}
	return builder.buildObject(objectQName);
}
 

import org.opensaml.xml.XMLObjectBuilder; //导入依赖的package包/类
/**
    * Builds a SAML Attribute of type String
    * 
    * @param name
    * @param value
    * @param builderFactory
    * @return
    * @throws ConfigurationException
    */
   private Attribute buildStringAttribute(String name, String value, XMLObjectBuilderFactory builderFactory) throws ConfigurationException {
SAMLObjectBuilder attrBuilder = (SAMLObjectBuilder) getSAMLBuilder().getBuilder(Attribute.DEFAULT_ELEMENT_NAME);
Attribute attrFirstName = (Attribute) attrBuilder.buildObject();
attrFirstName.setName(name);

// Set custom Attributes
XMLObjectBuilder stringBuilder = getSAMLBuilder().getBuilder(XSString.TYPE_NAME);
XSString attrValueFirstName = (XSString) stringBuilder.buildObject(AttributeValue.DEFAULT_ELEMENT_NAME, XSString.TYPE_NAME);
attrValueFirstName.setValue(value);

attrFirstName.getAttributeValues().add(attrValueFirstName);
return attrFirstName;
   }
 

import org.opensaml.xml.XMLObjectBuilder; //导入依赖的package包/类
public static XMLObject buildXMLObject(QName objectQName)
        throws Exception {

    XMLObjectBuilder builder = org.opensaml.xml.Configuration.getBuilderFactory().getBuilder(objectQName);
    if (builder == null) {
        throw new Exception("Unable to retrieve builder for object QName "
                            + objectQName);
    }
    return builder.buildObject(objectQName.getNamespaceURI(), objectQName.getLocalPart(),
                               objectQName.getPrefix());
}