Java tutorial
package org.springframework.security.oauth2.provider; import java.io.Serializable; import java.util.Collection; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.Map; import java.util.Set; import org.springframework.security.core.GrantedAuthority; import org.springframework.security.oauth2.common.util.OAuth2Utils; import org.springframework.web.bind.annotation.SessionAttributes; /** * A request for authorization by an OAuth 2 Client, normally received and * processed by the AuthorizationEndpoint. This class is meant to be manipulated * throughout the authorization process, and is therefore treated as ephemeral * and not to be stored long term. For long term storage, use the read-only * {@link OAuth2Request} class. * * HTTP request parameters are stored in the parameters map, and any processing * the server makes throughout the lifecycle of a request are stored on * individual properties. The original request parameters will remain available * through the parameters map. For convenience, constants are defined in order * to get at those original values. However, the parameters map is unmodifiable * so that processing cannot drop the original values. * * This class is {@link Serializable} in order to support storage of the * authorization request as a {@link SessionAttributes} member while the end * user through the authorization process (which may span several page * requests). * * @author Ryan Heaton * @author Dave Syer * @author Amanda Anganes */ @SuppressWarnings("serial") public class AuthorizationRequest extends BaseRequest implements Serializable { /** * Map to hold the original, unchanged parameter set submitted by a user to * signal approval of the token grant approval. Once set this should not be * modified. */ private Map<String, String> approvalParameters = Collections.unmodifiableMap(new HashMap<String, String>()); /** * The value of the "state" parameter sent by the client in the request, if * sent by the client. As this must be echoed back to the client unchanged, * it should not be modified by any processing classes. */ private String state; /** * Resolved requested response types initialized (by the * OAuth2RequestFactory) with the response types originally requested. */ private Set<String> responseTypes = new HashSet<String>(); /** * Resolved resource IDs. This set may change during request processing. */ private Set<String> resourceIds = new HashSet<String>(); /** * Resolved granted authorities for this request. May change during request * processing. */ private Collection<? extends GrantedAuthority> authorities = new HashSet<GrantedAuthority>(); /** * Whether the request has been approved by the end user (or other process). * This will be altered by the User Approval Endpoint and/or the * UserApprovalHandler as appropriate. */ private boolean approved = false; /** * The resolved redirect URI of this request. A URI may be present in the * original request, in the authorizationParameters, or it may not be * provided, in which case it will be defaulted (by processing classes) to * the Client's default registered value. */ private String redirectUri; /** * Extension point for custom processing classes which may wish to store * additional information about the OAuth2 request. Since this class will * create a serializable OAuth2Request, all members of this extension map * must be serializable. */ private Map<String, Serializable> extensions = new HashMap<String, Serializable>(); /** * Default constructor. */ public AuthorizationRequest() { } /** * Full constructor. */ public AuthorizationRequest(Map<String, String> authorizationParameters, Map<String, String> approvalParameters, String clientId, Set<String> scope, Set<String> resourceIds, Collection<? extends GrantedAuthority> authorities, boolean approved, String state, String redirectUri, Set<String> responseTypes) { setClientId(clientId); setRequestParameters(authorizationParameters); // in case we need to // wrap the collection setScope(scope); // in case we need to parse if (resourceIds != null) { this.resourceIds = new HashSet<String>(resourceIds); } if (authorities != null) { this.authorities = new HashSet<GrantedAuthority>(authorities); } this.approved = approved; this.resourceIds = resourceIds; this.redirectUri = redirectUri; if (responseTypes != null) { this.responseTypes = responseTypes; } this.state = state; } public OAuth2Request createOAuth2Request() { return new OAuth2Request(getRequestParameters(), getClientId(), getAuthorities(), isApproved(), getScope(), getResourceIds(), getRedirectUri(), getResponseTypes(), getExtensions()); } /** * Convenience constructor for unit tests, where client ID and scope are * often the only needed fields. * * @param clientId * @param scopes */ public AuthorizationRequest(String clientId, Collection<String> scopes) { setClientId(clientId); setScope(scopes); // in case we need to parse } /** * Convenience method to set resourceIds and authorities on this request by * inheriting from a ClientDetails object. * * @param clientDetails */ public void setResourceIdsAndAuthoritiesFromClientDetails(ClientDetails clientDetails) { setResourceIds(clientDetails.getResourceIds()); setAuthorities(clientDetails.getAuthorities()); } public Map<String, String> getApprovalParameters() { return approvalParameters; } public void setApprovalParameters(Map<String, String> approvalParameters) { this.approvalParameters = approvalParameters; } public String getState() { return state; } public void setState(String state) { this.state = state; } public Set<String> getResponseTypes() { return responseTypes; } public void setResponseTypes(Set<String> responseTypes) { this.responseTypes = responseTypes; } public void setRedirectUri(String redirectUri) { this.redirectUri = redirectUri; } public void setApproved(boolean approved) { this.approved = approved; } public void setAuthorities(Collection<? extends GrantedAuthority> authorities) { if (authorities != null) { this.authorities = new HashSet<GrantedAuthority>(authorities); } } /** * @return the extensions */ public Map<String, Serializable> getExtensions() { return extensions; } public void setExtensions(Map<String, Serializable> extensions) { this.extensions = extensions; } public void setResourceIds(Set<String> resourceIds) { this.resourceIds = resourceIds; } public void setClientId(String clientId) { super.setClientId(clientId); } /** * Set the scope value. If the collection contains only a single scope * value, this method will parse that value into a collection using * {@link OAuth2Utils#parseParameterList}. * * @see TokenRequest#setScope * * @param scope */ public void setScope(Collection<String> scope) { super.setScope(scope); } /** * Set the Request Parameters on this authorization request, which represent * the original request parameters and should never be changed during * processing. The map passed in is wrapped in an unmodifiable map instance. * * @see TokenRequest#setRequestParameters * * @param requestParameters */ public void setRequestParameters(Map<String, String> requestParameters) { super.setRequestParameters(requestParameters); } /** * @return the resourceIds */ public Set<String> getResourceIds() { return resourceIds; } /** * @return the authorities */ public Collection<? extends GrantedAuthority> getAuthorities() { return authorities; } /** * @return the approved */ public boolean isApproved() { return approved; } /** * @return the redirectUri */ public String getRedirectUri() { return redirectUri; } @Override public int hashCode() { final int prime = 31; int result = super.hashCode(); result = prime * result + ((approvalParameters == null) ? 0 : approvalParameters.hashCode()); result = prime * result + ((responseTypes == null) ? 0 : responseTypes.hashCode()); result = prime * result + ((state == null) ? 0 : state.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (!super.equals(obj)) return false; if (getClass() != obj.getClass()) return false; AuthorizationRequest other = (AuthorizationRequest) obj; if (approvalParameters == null) { if (other.approvalParameters != null) return false; } else if (!approvalParameters.equals(other.approvalParameters)) return false; if (responseTypes == null) { if (other.responseTypes != null) return false; } else if (!responseTypes.equals(other.responseTypes)) return false; if (state == null) { if (other.state != null) return false; } else if (!state.equals(other.state)) return false; return true; } }