import com.nimbusds.openid.connect.sdk.op.OIDCProviderMetadata; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
protected OIDCProviderMetadata parse(byte[] bytes) throws ParseException {
    final OIDCProviderMetadata result = OIDCProviderMetadata.parse(JSONObjectUtils.parse(new String(bytes)));
    final JSONObject jsonResult = result.toJSONObject();
    for (final String key : dynamicResolvers.keySet()) {
        log.debug("Starting to resolve value for {}", key);
        final RefreshableMetadataValueResolver resolver = dynamicResolvers.get(key);
        try {
            resolver.refresh();
            final Object value = resolver.resolveSingle(null);
            if (value != null) {
                jsonResult.put(key, value);
                log.debug("The field {} updated to the result", key);
            }
        } catch (ResolverException e) {
            log.warn("Could not resolve a value for {̛}, ignoring it.", key, e);
        }
    }
    return OIDCProviderMetadata.parse(jsonResult);
}
 

import com.nimbusds.openid.connect.sdk.op.OIDCProviderMetadata; //导入依赖的package包/类
/**
	 * Retrieve provider metadata.
	 * Provider configuration information
	 * Obtaining the provider configuration information can be done either out-of-band or using the optional discovery process:
	 *
	 * @throws IOException Signals that an I/O exception has occurred.
	 * @throws ParseException the parse exception
	 * @throws KeyStoreException
	 * @throws CertificateException
	 * @throws NoSuchAlgorithmException
	 * @throws KeyManagementException
	 */
	public void retrieveProviderMetadata() throws IOException, ParseException, KeyManagementException, NoSuchAlgorithmException, CertificateException, KeyStoreException {
		
		URL providerConfigurationURL = issuerURI.resolve(URLPATH_WELL_KNOWN_OPENID).toURL();
//		System.out.println(providerConfigurationURL);
		URLConnection conn = providerConfigurationURL.openConnection();

		if (trustStoreFile != null) {
			Trust.trustSpecific((HttpsURLConnection) conn, trustStoreFile);
		}
		InputStream stream = conn.getInputStream();
		// Read all data from URL
		String providerInfo = null;
		try (java.util.Scanner s = new java.util.Scanner(stream)) {
			providerInfo = s.useDelimiter("\\A").hasNext() ? s.next() : "";
		}
		setProviderMetadata(OIDCProviderMetadata.parse(providerInfo));
	}
 

import com.nimbusds.openid.connect.sdk.op.OIDCProviderMetadata; //导入依赖的package包/类
@Override
public void providerConfiguration(RequestPath path, HttpServletRequest req, HttpServletResponse resp) throws IOException {
	logger.log("Provider configuration requested.");
	logger.logHttpRequest(req, null);
	try {
		OIDCProviderMetadata md = getDefaultOPMetadata();
		String mdStr = md.toJSONObject().toString();

		resp.setContentType("application/json");
		resp.getWriter().write(mdStr);

		resp.flushBuffer();
		logger.log("Returning default provider config.");
		logger.logHttpResponse(resp, mdStr);
	} catch (IOException | ParseException ex) {
		logger.log("Failed to process default provider config.", ex);
		resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
		resp.flushBuffer();
		logger.logHttpResponse(resp, null);
	}
}
 

import com.nimbusds.openid.connect.sdk.op.OIDCProviderMetadata; //导入依赖的package包/类
@Override
public Response handle(HTTPRequest httpRequest, OIDCResourceReference reference) throws Exception
{
    Issuer issuer = this.manager.getIssuer();
    List<SubjectType> subjectTypes = Arrays.asList(SubjectType.PUBLIC);
    URI jwkSetURI = this.manager.createEndPointURI(JWKOIDCEndpoint.HINT);

    OIDCProviderMetadata metadata = new OIDCProviderMetadata(issuer, subjectTypes, jwkSetURI);

    metadata.setAuthorizationEndpointURI(this.manager.createEndPointURI(AuthorizationOIDCEndpoint.HINT));
    metadata.setTokenEndpointURI(this.manager.createEndPointURI(TokenOIDCEndpoint.HINT));
    metadata.setUserInfoEndpointURI(this.manager.createEndPointURI(UserInfoOIDCEndpoint.HINT));

    return new ContentResponse(CommonContentTypes.APPLICATION_JSON, metadata.toJSONObject().toString(),
        HTTPResponse.SC_OK);
}
 

import com.nimbusds.openid.connect.sdk.op.OIDCProviderMetadata; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
public Iterable<OIDCProviderMetadata> resolve(CriteriaSet criteria) throws ResolverException {
    ComponentSupport.ifNotInitializedThrowUninitializedComponentException(this);
    ComponentSupport.ifDestroyedThrowDestroyedComponentException(this);

    final IssuerCriterion issuerCriterion = criteria.get(IssuerCriterion.class);
    if (issuerCriterion == null || issuerCriterion.getIssuer() == null) {
        log.trace("No issuer criteria found, returning all");
        return getBackingStore().getOrderedInformation();
    }
    // TODO: support other criterion
    return lookupIdentifier(issuerCriterion.getIssuer());
}
 

import com.nimbusds.openid.connect.sdk.op.OIDCProviderMetadata; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
public OIDCProviderMetadata resolveSingle(CriteriaSet criteria) throws ResolverException {
    final Iterable<OIDCProviderMetadata> iterable = resolve(criteria);
    if (iterable != null) {
        final Iterator<OIDCProviderMetadata> iterator = iterable.iterator();
        if (iterator != null && iterator.hasNext()) {
            return iterator.next();
        }
    }
    log.warn("Could not find any clients with the given criteria");
    return null;
}
 

import com.nimbusds.openid.connect.sdk.op.OIDCProviderMetadata; //导入依赖的package包/类
@Test
public void testSuccess() throws Exception {
    final IssuerCriterion criterion = new IssuerCriterion(new Issuer(issuer));
    final OIDCProviderMetadata metadata = resolver.resolveSingle(new CriteriaSet(criterion));
    Assert.assertNotNull(metadata);
    Assert.assertEquals(metadata.getIssuer().getValue(), issuer);
}
 

import com.nimbusds.openid.connect.sdk.op.OIDCProviderMetadata; //导入依赖的package包/类
@Test
public void testDynamic() throws Exception {
    final IssuerCriterion criterion = new IssuerCriterion(new Issuer(issuer));
    OIDCProviderMetadata metadata = resolver.resolveSingle(new CriteriaSet(criterion));
    Assert.assertNotNull(metadata);
    Assert.assertEquals(metadata.getIssuer().getValue(), issuer);
    ((DynamicFilesystemProviderMetadataResolver)resolver).refresh();
    metadata = resolver.resolveSingle(new CriteriaSet(criterion));
    Assert.assertNotNull(metadata.getCustomParameter(name));
    Assert.assertEquals(metadata.getCustomParameter(name), value);
}
 

import com.nimbusds.openid.connect.sdk.op.OIDCProviderMetadata; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
@Nonnull
public Iterable<OIDCProviderMetadata> resolve(@Nullable final CriteriaSet criteria) throws ResolverException {

    return resolver.resolve(criteria);
}
 

import com.nimbusds.openid.connect.sdk.op.OIDCProviderMetadata; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
@Nullable
public OIDCProviderMetadata resolveSingle(@Nullable final CriteriaSet criteria) throws ResolverException {

    return resolver.resolveSingle(criteria);
}
 

import com.nimbusds.openid.connect.sdk.op.OIDCProviderMetadata; //导入依赖的package包/类
protected OIDCProviderMetadata getDefaultOPMetadata() throws ParseException {
	Issuer issuer = getMetadataIssuer();
	List<SubjectType> subjectTypes = Arrays.asList(SubjectType.PUBLIC);
	URI jwksUri = UriBuilder.fromUri(baseUri).path(JWKS_PATH).build();
	OIDCProviderMetadata md = new OIDCProviderMetadata(issuer, subjectTypes, jwksUri);
	md.applyDefaults();

	// endpoints
	URI authzEndpt = getMetadataAuthorizationEndpoint();
	URI tokenEndpt = getMetadataTokenEndpoint();
	URI userInfoEndpt = getMetadataUserinfoEndpoint();
	URI registrationEndpt = getMetadataRegistrationEndpoint();
	md.setAuthorizationEndpointURI(authzEndpt);
	md.setTokenEndpointURI(tokenEndpt);
	md.setUserInfoEndpointURI(userInfoEndpt);
	md.setRegistrationEndpointURI(registrationEndpt);

	// , ResponseType.parse("id_token"), ResponseType.parse("token id_token"));
	Scope scopes = new Scope("openid");
	List<ResponseType> responseTypes = Arrays.asList(ResponseType.parse("code"), ResponseType.parse("id_token"),
			ResponseType.parse("token id_token"));
	List<ResponseMode> responseModes = Arrays.asList(ResponseMode.QUERY, ResponseMode.FRAGMENT, ResponseMode.FORM_POST);
	List<GrantType> grantTypes = Arrays.asList(GrantType.AUTHORIZATION_CODE, GrantType.IMPLICIT);
	md.setScopes(scopes);
	md.setResponseTypes(responseTypes);
	md.setResponseModes(responseModes);
	md.setGrantTypes(grantTypes);

	// algorithms
	List<JWSAlgorithm> jwsAlgs = Arrays.asList(JWSAlgorithm.RS256, JWSAlgorithm.parse("none"));
	md.setIDTokenJWSAlgs(jwsAlgs);

	List<ClientAuthenticationMethod> authMethods = Arrays.asList(ClientAuthenticationMethod.CLIENT_SECRET_BASIC);
	md.setTokenEndpointAuthMethods(authMethods);

	List<Display> displays = Arrays.asList(Display.PAGE);
	md.setDisplays(displays);

	return md;
}
 

import com.nimbusds.openid.connect.sdk.op.OIDCProviderMetadata; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
protected OIDCProviderMetadata parse(byte[] bytes) throws ParseException {
    return OIDCProviderMetadata.parse(JSONObjectUtils.parse(new String(bytes)));
}
 

import com.nimbusds.openid.connect.sdk.op.OIDCProviderMetadata; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
protected Issuer getKey(OIDCProviderMetadata value) {
    return value.getIssuer();
}
 

import com.nimbusds.openid.connect.sdk.op.OIDCProviderMetadata; //导入依赖的package包/类
@Test
public void testNotFound() throws Exception {
    final IssuerCriterion criterion = new IssuerCriterion(new Issuer("not_found"));
    final OIDCProviderMetadata metadata = resolver.resolveSingle(new CriteriaSet(criterion));
    Assert.assertNull(metadata);
}
 

import com.nimbusds.openid.connect.sdk.op.OIDCProviderMetadata; //导入依赖的package包/类
/**
 * Sets the provider metadata by object.
 *
 * @param providerMetadata the new provider metadata
 */
void setProviderMetadata(OIDCProviderMetadata providerMetadata) {
	this.providerMetadata = providerMetadata;
	authorizationEndpointURI = providerMetadata.getAuthorizationEndpointURI();
	userInfoEndpointURI = providerMetadata.getUserInfoEndpointURI();
}
 

import com.nimbusds.openid.connect.sdk.op.OIDCProviderMetadata; //导入依赖的package包/类
public DiscoveryEndpoint(OIDCProviderMetadata providerMetadata) {
	Objects.requireNonNull(providerMetadata, "providerMetadata must not be null");
	this.providerMetadata = providerMetadata;
}
 

import com.nimbusds.openid.connect.sdk.op.OIDCProviderMetadata; //导入依赖的package包/类
@Bean
public DiscoveryEndpoint discoveryEndpoint() {
	return new DiscoveryEndpoint(new OIDCProviderMetadata(new Issuer("http://example.com"),
			Collections.singletonList(SubjectType.PUBLIC), URI.create("http://example.com/jwks.json")));
}
 

import com.nimbusds.openid.connect.sdk.op.OIDCProviderMetadata; //导入依赖的package包/类
public OIDCProviderMetadata getProviderMetadata() {
    return this.providerMetadata;
}
 

import com.nimbusds.openid.connect.sdk.op.OIDCProviderMetadata; //导入依赖的package包/类
public void setProviderMetadata(final OIDCProviderMetadata providerMetadata) {
    this.providerMetadata = providerMetadata;
}