org.xdi.oxauth.client.GluuConfigurationClient クラス

org.xdi.oxauth.client.GluuConfigurationClient の継承関係図

org.xdi.oxauth.client.GluuConfigurationClient 連携図

公開メンバ関数
	GluuConfigurationClient (String url)
String	getHttpMethod ()
GluuConfigurationResponse	execGluuConfiguration ()
String	getUrl ()
void	setUrl (String url)
T	getRequest ()
void	setRequest (T request)
V	getResponse ()
void	setResponse (V response)
ClientExecutor	getExecutor ()
void	setExecutor (ClientExecutor executor)
String	getRequestAsString ()
String	getResponseAsString ()
void	closeConnection ()
List< Cookie >	getCookies ()
Map< String, String >	getHeaders ()

静的公開メンバ関数
static void	putAllFormParameters (ClientRequest p_clientRequest, BaseRequest p_request)

限定公開メンバ関数
void	addReqParam (String p_key, HasParamName p_value)
void	addReqParam (String p_key, String p_value)
void	initClientRequest ()

限定公開変数類
T	request
V	response
ClientRequest	clientRequest
ClientResponse< String >	clientResponse
ClientExecutor	executor

非公開メンバ関数
Map< Integer, Set< String > >	mapJsonToAuthLevelMapping (JSONObject jsonObject)
Map< String, Set< String > >	mapJsonToScopeToClaimsMapping (JSONObject jsonObject)

静的非公開変数類
static final Logger	LOG = Logger.getLogger(GluuConfigurationClient.class)

詳解

Created by eugeniuparvan on 8/12/16.

バージョン

December 26, 2016

構築子と解体子

GluuConfigurationClient()

org.xdi.oxauth.client.GluuConfigurationClient.GluuConfigurationClient ( String  url )

inline

                                               {
        super(url);
    }

関数詳解

addReqParam() [1/2]

void org.xdi.oxauth.client.BaseClient< T extends BaseRequest, V extends BaseResponse >.addReqParam ( String  p_key, HasParamName  p_value  )

inlineprotectedinherited

                                                                   {
        if (p_value != null) {
            addReqParam(p_key, p_value.getParamName());
        }
    }

addReqParam() [2/2]

void org.xdi.oxauth.client.BaseClient< T extends BaseRequest, V extends BaseResponse >.addReqParam ( String  p_key, String  p_value  )

inlineprotectedinherited

                                                             {
        if (Util.allNotBlank(p_key, p_value)) {
            if (request.getAuthorizationMethod() == AuthorizationMethod.FORM_ENCODED_BODY_PARAMETER) {
                clientRequest.formParameter(p_key, p_value);
            } else {
                clientRequest.queryParameter(p_key, p_value);
            }
        }
    }

closeConnection()

void org.xdi.oxauth.client.BaseClient< T extends BaseRequest, V extends BaseResponse >.closeConnection ( )

inlineinherited

                                  {
        try {
            if (clientResponse != null) {
                clientResponse.releaseConnection();
            }
            if (clientRequest != null && clientRequest.getExecutor() != null) {
                clientRequest.getExecutor().close();
            }
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
        }
    }

execGluuConfiguration()

GluuConfigurationResponse org.xdi.oxauth.client.GluuConfigurationClient.execGluuConfiguration ( )

inline

                                                             {
        initClientRequest();

        setRequest(new GluuConfigurationRequest());

        // Prepare request parameters
        clientRequest.header("Content-Type", MediaType.APPLICATION_JSON);
        clientRequest.setHttpMethod(getHttpMethod());

        // Call REST Service and handle response
        try {
            clientResponse = clientRequest.get(String.class);

            setResponse(new GluuConfigurationResponse());

            String entity = clientResponse.getEntity(String.class);
            getResponse().setEntity(entity);
            getResponse().setHeaders(clientResponse.getMetadata());
            getResponse().setStatus(clientResponse.getStatus());

            if (StringUtils.isNotBlank(entity)) {
                JSONObject jsonObj = new JSONObject(entity);

                if (jsonObj.has(ID_GENERATION_ENDPOINT)) {
                    getResponse().setIdGenerationEndpoint(jsonObj.getString(ID_GENERATION_ENDPOINT));
                }
                if (jsonObj.has(INTROSPECTION_ENDPOINT)) {
                    getResponse().setIntrospectionEndpoint(jsonObj.getString(INTROSPECTION_ENDPOINT));
                }
                if (jsonObj.has(AUTH_LEVEL_MAPPING)) {
                    getResponse().setAuthLevelMapping(mapJsonToAuthLevelMapping(jsonObj.getJSONObject(AUTH_LEVEL_MAPPING)));
                }
                if (jsonObj.has(SCOPE_TO_CLAIMS_MAPPING)) {
                    getResponse().setScopeToClaimsMapping(mapJsonToScopeToClaimsMapping(jsonObj.getJSONObject(SCOPE_TO_CLAIMS_MAPPING)));
                }
            }
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
        } finally {
            closeConnection();
        }

        return getResponse();
    }

getCookies()

List<Cookie> org.xdi.oxauth.client.BaseClient< T extends BaseRequest, V extends BaseResponse >.getCookies ( )

inlineinherited

                                     {
        return cookies;
    }

getExecutor()

ClientExecutor org.xdi.oxauth.client.BaseClient< T extends BaseRequest, V extends BaseResponse >.getExecutor ( )

inlineinherited

                                        {
        return executor;
    }

getHeaders()

Map<String, String> org.xdi.oxauth.client.BaseClient< T extends BaseRequest, V extends BaseResponse >.getHeaders ( )

inlineinherited

                                            {
        return headers;
    }

getHttpMethod()

String org.xdi.oxauth.client.GluuConfigurationClient.getHttpMethod ( )

inline

                                  {
        return HttpMethod.GET;
    }

getRequest()

T org.xdi.oxauth.client.BaseClient< T extends BaseRequest, V extends BaseResponse >.getRequest ( )

inlineinherited

                          {
        return request;
    }

getRequestAsString()

String org.xdi.oxauth.client.BaseClient< T extends BaseRequest, V extends BaseResponse >.getRequestAsString ( )

inlineinherited

                                       {
        StringBuilder sb = new StringBuilder();

        try {
            URL theUrl = new URL(url);

            if (getHttpMethod().equals(HttpMethod.POST)) {
                sb.append(HttpMethod.POST).append(" ").append(theUrl.getPath()).append(" HTTP/1.1");
                if (StringUtils.isNotBlank(request.getContentType())) {
                    sb.append("\n");
                    sb.append("Content-Type: ").append(request.getContentType());
                }
                if (StringUtils.isNotBlank(request.getMediaType())) {
                    sb.append("\n");
                    sb.append("Accept: ").append(request.getMediaType());
                }
                sb.append("\n");
                sb.append("Host: ").append(theUrl.getHost());

                if (request instanceof AuthorizationRequest) {
                    AuthorizationRequest authorizationRequest = (AuthorizationRequest) request;
                    if (authorizationRequest.isUseNoRedirectHeader()) {
                        sb.append("\n");
                        sb.append("X-Gluu-NoRedirect: true");
                    }
                }
                if (request.getAuthorizationMethod() == null) {
                    if (request.getAuthenticationMethod() == null
                            || request.getAuthenticationMethod() == AuthenticationMethod.CLIENT_SECRET_BASIC) {
                        if (request.hasCredentials()) {
                            String encodedCredentials = request.getEncodedCredentials();
                            sb.append("\n");
                            sb.append("Authorization: Basic ").append(encodedCredentials);
                        }
                    }
                } else if (request.getAuthorizationMethod() == AuthorizationMethod.AUTHORIZATION_REQUEST_HEADER_FIELD) {
                    if (request instanceof UserInfoRequest) {
                        String accessToken = ((UserInfoRequest) request).getAccessToken();
                        sb.append("\n");
                        sb.append("Authorization: Bearer ").append(accessToken);
                    }
                }

                sb.append("\n");
                sb.append("\n");
                sb.append(request.getQueryString());
            } else if (getHttpMethod().equals(HttpMethod.GET)) {
                sb.append("GET ").append(theUrl.getPath());
                if (StringUtils.isNotBlank(request.getQueryString())) {
                    sb.append("?").append(request.getQueryString());
                }
                sb.append(" HTTP/1.1");
                sb.append("\n");
                sb.append("Host: ").append(theUrl.getHost());

                if (request instanceof AuthorizationRequest) {
                    AuthorizationRequest authorizationRequest = (AuthorizationRequest) request;
                    if (authorizationRequest.isUseNoRedirectHeader()) {
                        sb.append("\n");
                        sb.append("X-Gluu-NoRedirect: true");
                    }
                }
                if (request.getAuthorizationMethod() == null) {
                    if (request.hasCredentials()) {
                        String encodedCredentials = request.getEncodedCredentials();
                        sb.append("\n");
                        sb.append("Authorization: Basic ").append(encodedCredentials);
                    } else if (request instanceof RegisterRequest) {
                        RegisterRequest r = (RegisterRequest) request;
                        String registrationAccessToken = r.getRegistrationAccessToken();
                        sb.append("\n");
                        sb.append("Authorization: Bearer ").append(registrationAccessToken);
                    }
                } else if (request.getAuthorizationMethod() == AuthorizationMethod.AUTHORIZATION_REQUEST_HEADER_FIELD) {
                    if (request instanceof UserInfoRequest) {
                        String accessToken = ((UserInfoRequest) request).getAccessToken();
                        sb.append("\n");
                        sb.append("Authorization: Bearer ").append(accessToken);
                    }
                }
            }
        } catch (MalformedURLException e) {
            LOG.error(e.getMessage(), e);
        }

        return sb.toString();
    }

getResponse()

V org.xdi.oxauth.client.BaseClient< T extends BaseRequest, V extends BaseResponse >.getResponse ( )

inlineinherited

                           {
        return response;
    }

getResponseAsString()

String org.xdi.oxauth.client.BaseClient< T extends BaseRequest, V extends BaseResponse >.getResponseAsString ( )

inlineinherited

                                        {
        StringBuilder sb = new StringBuilder();

        if (response != null) {
            sb.append("HTTP/1.1 ").append(response.getStatus());
            if (response.getHeaders() != null) {
                for (String key : response.getHeaders().keySet()) {
                    sb.append("\n")
                            .append(key)
                            .append(": ")
                            .append(response.getHeaders().get(key).get(0));
                }
            }
            if (response.getEntity() != null) {
                sb.append("\n");
                sb.append("\n");
                sb.append(response.getEntity());
            }
        }
        return sb.toString();
    }

getUrl()

String org.xdi.oxauth.client.BaseClient< T extends BaseRequest, V extends BaseResponse >.getUrl ( )

inlineinherited

                           {
        return url;
    }

initClientRequest()

void org.xdi.oxauth.client.BaseClient< T extends BaseRequest, V extends BaseResponse >.initClientRequest ( )

inlineprotectedinherited

                                       {
        if (this.executor == null) {
            this.clientRequest = new ClientRequest(getUrl());
        } else {
            this.clientRequest = new ClientRequest(getUrl(), this.executor);
        }
        for (Cookie cookie : cookies) {
            clientRequest.cookie(cookie);
        }
        for (Map.Entry<String, String> headerEntry : headers.entrySet()) {
            clientRequest.header(headerEntry.getKey(), headerEntry.getValue());
        }
    }

mapJsonToAuthLevelMapping()

Map<Integer, Set<String> > org.xdi.oxauth.client.GluuConfigurationClient.mapJsonToAuthLevelMapping ( JSONObject  jsonObject )

inlineprivate

                                                                                       {
        Map<Integer, Set<String>> authLevelMapping = new HashMap<Integer, Set<String>>();

        Iterator<?> keys = jsonObject.keys();
        while (keys.hasNext()) {
            try {
                String key = (String) keys.next();
                Integer level = new Integer(key);

                authLevelMapping.put(level, new HashSet<String>());

                JSONArray jsonArray = jsonObject.getJSONArray(key);
                for (int i = 0; i < jsonArray.length(); i++)
                    authLevelMapping.get(level).add(jsonArray.getString(i));
            } catch (Exception e) {
                LOG.error(e.getMessage(), e);
            }
        }
        return authLevelMapping;
    }

mapJsonToScopeToClaimsMapping()

Map<String, Set<String> > org.xdi.oxauth.client.GluuConfigurationClient.mapJsonToScopeToClaimsMapping ( JSONObject  jsonObject )

inlineprivate

                                                                                          {
        Map<String, Set<String>> scopeToClaimsMapping = new HashMap<String, Set<String>>();
        Iterator<?> keys = jsonObject.keys();
        while (keys.hasNext()) {
            try {
                String scope = (String) keys.next();

                scopeToClaimsMapping.put(scope, new HashSet<String>());

                JSONArray jsonArray = jsonObject.getJSONArray(scope);
                for (int i = 0; i < jsonArray.length(); i++)
                    scopeToClaimsMapping.get(scope).add(jsonArray.getString(i));
            } catch (Exception e) {
                LOG.error(e.getMessage(), e);
            }
        }
        return scopeToClaimsMapping;
    }

putAllFormParameters()

static void org.xdi.oxauth.client.BaseClient< T extends BaseRequest, V extends BaseResponse >.putAllFormParameters ( ClientRequest  p_clientRequest, BaseRequest  p_request  )

inlinestaticinherited

                                                                                                  {
        if (p_clientRequest != null && p_request != null) {
            final Map<String, String> parameters = p_request.getParameters();
            if (parameters != null && !parameters.isEmpty()) {
                for (Map.Entry<String, String> e : parameters.entrySet()) {
                    p_clientRequest.formParameter(e.getKey(), e.getValue());
                }
            }
        }
    }

setExecutor()

void org.xdi.oxauth.client.BaseClient< T extends BaseRequest, V extends BaseResponse >.setExecutor ( ClientExecutor  executor )

inlineinherited

                                                     {
        this.executor = executor;
    }

setRequest()

void org.xdi.oxauth.client.BaseClient< T extends BaseRequest, V extends BaseResponse >.setRequest ( T  request )

inlineinherited

                                      {
        this.request = request;
    }

setResponse()

void org.xdi.oxauth.client.BaseClient< T extends BaseRequest, V extends BaseResponse >.setResponse ( V  response )

inlineinherited

                                        {
        this.response = response;
    }

setUrl()

void org.xdi.oxauth.client.BaseClient< T extends BaseRequest, V extends BaseResponse >.setUrl ( String  url )

inlineinherited

                                   {
        this.url = url;
    }

メンバ詳解

clientRequest

ClientRequest org.xdi.oxauth.client.BaseClient< T extends BaseRequest, V extends BaseResponse >.clientRequest

protectedinherited

clientResponse

ClientResponse<String> org.xdi.oxauth.client.BaseClient< T extends BaseRequest, V extends BaseResponse >.clientResponse

protectedinherited

executor

ClientExecutor org.xdi.oxauth.client.BaseClient< T extends BaseRequest, V extends BaseResponse >.executor

protectedinherited

LOG

final Logger org.xdi.oxauth.client.GluuConfigurationClient.LOG = Logger.getLogger(GluuConfigurationClient.class)

staticprivate

request

T org.xdi.oxauth.client.BaseClient< T extends BaseRequest, V extends BaseResponse >.request

protectedinherited

response

V org.xdi.oxauth.client.BaseClient< T extends BaseRequest, V extends BaseResponse >.response

protectedinherited

---

このクラス詳解は次のファイルから抽出されました:

• D:/AppData/OpenId/gluu/src/oxAuth/Client/src/main/java/org/xdi/oxauth/client/GluuConfigurationClient.java