import org.openid4java.message.MessageExtension; //导入依赖的package包/类
/**
 * Add Simple Register extension message to the response message.
 * 
 * @param response
 *            the response message to add to
 * @param persona
 *            the persona
 * @throws MessageException
 *             if add extension failed
 */
private void addSReg(final Message response, final Persona persona)
		throws MessageException {
	if (authRequest.hasExtension(SRegMessage.OPENID_NS_SREG)) {
		MessageExtension ext = authRequest
				.getExtension(SRegMessage.OPENID_NS_SREG);
		if (ext instanceof SRegRequest) {
			SRegRequest sregReq = (SRegRequest) ext;
			// data released by the user
			if (persona != null) {
				Map<String, String> userDataSReg = persona.toAliasValueMap();

				SRegResponse sregResp = SRegResponse.createSRegResponse(
						sregReq, userDataSReg);
				// (alternatively) manually add attribute values
				// sregResp.addAttribute("email", email);
				response.addExtension(sregResp);
			}
		} else {
			throw new UnsupportedOperationException(ext.getClass()
					+ " is unsupported.");
		}
	}
}
 

import org.openid4java.message.MessageExtension; //导入依赖的package包/类
/**
 * Instantiates the apropriate Simple Registration object
 * (request / response) for the supplied parameter list.
 *
 * Similar to SRegMessage.getExtension(), but sets the SREG 1.1 type URI.
 *
 * @param parameterList         The Simple Registration specific parameters
 *                              (without the openid.<ext_alias> prefix)
 *                              extracted from the openid message.
 * @param isRequest             Indicates whether the parameters were
 *                              extracted from an OpenID request (true),
 *                              or from an OpenID response.
 * @return                      MessageExtension implementation for
 *                              the supplied extension parameters.
 * @throws MessageException     If a Simple Registration object could not be
 *                              instantiated from the supplied parameter list.
 */
public MessageExtension getExtension(
        ParameterList parameterList, boolean isRequest)
        throws MessageException
{
    SRegMessage sreg;

    if ( parameterList.hasParameter("required") ||
         parameterList.hasParameter("optional"))

        sreg = SRegRequest.createSRegRequest(parameterList);

    else
        sreg = SRegResponse.createSRegResponse(parameterList);

    sreg.setTypeUri(SRegMessage.OPENID_NS_SREG11);

    return sreg;
}
 

import org.openid4java.message.MessageExtension; //导入依赖的package包/类
/**
 * @param httpReq
 * @param authSuccess
 * @throws MessageException 
 */
private void receiveSimpleRegistration(HttpServletRequest httpReq,
		AuthSuccess authSuccess) throws MessageException {
	if (authSuccess.hasExtension(SRegMessage.OPENID_NS_SREG)) {
		MessageExtension ext = authSuccess
				.getExtension(SRegMessage.OPENID_NS_SREG);
		if (ext instanceof SRegResponse) {
			SRegResponse sregResp = (SRegResponse) ext;
			for (Iterator iter = sregResp.getAttributeNames()
					.iterator(); iter.hasNext();) {
				String name = (String) iter.next();
				String value = sregResp.getParameterValue(name);
				httpReq.setAttribute(name, value);
			}
		}
	}
}
 

import org.openid4java.message.MessageExtension; //导入依赖的package包/类
private Message processSRegExtension(Message token, final AuthRequest authRequest) throws MessageException {
    String sregNamespace = detectSRegVersion(authRequest);
    if (sregNamespace != null) {
        MessageExtension ext = authRequest.getExtension(sregNamespace);
        if (ext instanceof SRegRequest) {
            SRegRequest sregReq = (SRegRequest) ext;
            SRegResponse sregResp = SRegResponse.createSRegResponse(sregReq, getValidUser().getUserDataMap());
            token.addExtension(sregResp, "sreg");
        } else if (ext instanceof SRegResponse) {
            // what to do here?
        } else {
            final String message = String.format("TODO - Support of '%s'", ext.getClass().getCanonicalName());
            throw new UnsupportedOperationException(message);
        }
    }
    return token;
}
 

import org.openid4java.message.MessageExtension; //导入依赖的package包/类
private Message processAxExtension(Message token, final AuthRequest authRequest) throws MessageException {
    if (authRequest.hasExtension(AxMessage.OPENID_NS_AX)) {
        MessageExtension extension = authRequest.getExtension(AxMessage.OPENID_NS_AX);
        if (extension instanceof FetchRequest) {
            final FetchRequest fetchRequest = (FetchRequest) extension;
            final Map userDataMap = getValidUser().getUserDataMap();
            final FetchResponse fetchResponse = FetchResponse.createFetchResponse(fetchRequest, userDataMap);
            token.addExtension(fetchResponse, "ax");
        } else {
            throw new UnsupportedOperationException("TODO: if (ext instanceof StoreRequest)");
        }
    }
    return token;
}
 

import org.openid4java.message.MessageExtension; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public MessageExtension getMessageExtension(String userId, String profileName, OpenIDAuthRequestDTO requestDTO)
        throws IdentityException {

    MessageExtension message = null;
    PapeResponse papeResponse = null;
    AuthRequest authRequest = null;

    try {
        authRequest = request.getAuthRequest();

        if (authRequest != null) {
            message = authRequest.getExtension(PapeMessage.OPENID_NS_PAPE);

            if (message instanceof PapeRequest) {
                papeResponse = PapeResponse.createPapeResponse();
                if (request.isPhishingResistanceLogin()) {
                    papeResponse.addAuthPolicy(PapeMessage.PAPE_POLICY_PHISHING_RESISTANT);
                    //papeResponse.setNistAuthLevel(1);  TODO
                }
                if (request.isMultifactorLogin()) {
                    papeResponse.addAuthPolicy(PapeMessage.PAPE_POLICY_MULTI_FACTOR);
                    //papeResponse.setNistAuthLevel(2);  TODO
                }
            }
        }
    } catch (MessageException e) {
        log.error("Failed to create message extension for PAPE", e);
        throw IdentityException.error("Failed to create message extension for PAPE", e);
    }

    return papeResponse;
}
 

import org.openid4java.message.MessageExtension; //导入依赖的package包/类
/**
 * Add attributes to the response message.
 * 
 * @param response
 *            the response message to add to
 * @throws MessageException
 *             if add failed
 */
private void addAttributes(final Message response, Persona persona)
		throws MessageException {
	if (authRequest.hasExtension(AxMessage.OPENID_NS_AX)) {
		MessageExtension ext = authRequest
				.getExtension(AxMessage.OPENID_NS_AX);
		if (ext instanceof FetchRequest) {
			FetchRequest fetchReq = (FetchRequest) ext;

			FetchResponse fetchResp = FetchResponse.createFetchResponse();

			@SuppressWarnings("unchecked")
			Map<String, String> attributes = (Map<String, String>) fetchReq
					.getAttributes();

			Map<String, String> typeValueMap = persona.toTypeValueMap();
			Map<String, String> aliasValueMap = persona.toAliasValueMap();

			for (Map.Entry<String, String> entry : attributes.entrySet()) {
				String alias = entry.getKey();
				String type = entry.getValue();

				String value = typeValueMap.get(type);
				if (value == null) {
					value = aliasValueMap.get(alias);
				}
				if (value != null) {
					fetchResp.addAttribute(alias, type, value);
				}

				Attribute attribute = persona.getAttributeByType(type);
				if (attribute != null) {
					for (String v : attribute.getValues()) {
						fetchResp.addAttribute(alias, type, v);
					}
				}
			}

			response.addExtension(fetchResp);
		} else { // if (ext instanceof StoreRequest)
			throw new UnsupportedOperationException(ext.getClass()
					+ " is unsupported.");
		}
	}
}
 

import org.openid4java.message.MessageExtension; //导入依赖的package包/类
/**
 * Creates an instance of MessageExtension for the OpenID authentication
 * response
 *
 * @param requestDTO
 * @param requestDTO OpenID authentication request
 * @return An instance of MessageExtension
 * @throws IdentityException
 */
public abstract MessageExtension getMessageExtension(String userId, String profileName,
                                                     OpenIDAuthRequestDTO requestDTO)
        throws IdentityException;