com.lonepulse.zombielink.request.RequestUtils.java Source code

Java tutorial

Introduction

Here is the source code for com.lonepulse.zombielink.request.RequestUtils.java

Source

package com.lonepulse.zombielink.request;

/*
 * #%L
 * ZombieLink
 * %%
 * Copyright (C) 2013 - 2014 Lonepulse
 * %%
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * #L%
 */

import static com.lonepulse.zombielink.util.Assert.assertNotNull;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;

import org.apache.http.client.methods.HttpDelete;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpHead;
import org.apache.http.client.methods.HttpOptions;
import org.apache.http.client.methods.HttpPatch;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.client.methods.HttpRequestBase;
import org.apache.http.client.methods.HttpTrace;

import com.lonepulse.zombielink.annotation.FormParams;
import com.lonepulse.zombielink.annotation.Headers;
import com.lonepulse.zombielink.annotation.Param;
import com.lonepulse.zombielink.annotation.QueryParams;
import com.lonepulse.zombielink.annotation.Request.RequestMethod;
import com.lonepulse.zombielink.proxy.InvocationContext;
import com.lonepulse.zombielink.util.Metadata;

/**
 * <p>This utility class offers some common operations which are used in building requests - most commonly 
 * using the information contained within a {@link InvocationContext}.
 * 
 * @version 1.2.0
 * <br><br>
 * @since 1.3.0
 * <br><br>
 * @author <a href="http://sahan.me">Lahiru Sahan Jayasinghe</a>
 */
final class RequestUtils {

    private RequestUtils() {
    }

    /**
     * <p>Finds all <b><i>constant</i> request parameters</b> in the given {@link InvocationContext}.</p> 
     * <p>Constant request parameters are introduced with @{@link Param} at <b>request level</b> using 
     * the @{@link QueryParams} annotation.</p>
     *
     * @param context
     *          the {@link InvocationContext} from which all {@link QueryParams} annotations applied 
     *          on the endpoint method will be extracted
     * <br><br>
     * @return an <b>unmodifiable</b> {@link List} which aggregates all the @{@link Param} annotations 
     *             found on the {@link QueryParams} annotation
     * <br><br>
     * @throws NullPointerException
     *          if the supplied {@link InvocationContext} was {@code null}
     * <br><br>
     * @since 1.3.0
     */
    static List<Param> findStaticQueryParams(InvocationContext context) {

        Method request = assertNotNull(context).getRequest();

        QueryParams queryParams = request.getAnnotation(QueryParams.class);

        return Collections.unmodifiableList(
                queryParams != null ? Arrays.asList(queryParams.value()) : new ArrayList<Param>());
    }

    /**
     * <p>Finds all <b><i>constant</i> form parameters</b> in the given {@link InvocationContext}.</p> 
     * <p>Constant form parameters are introduced with @{@link Param} at <b>request level</b> using 
     * the @{@link FormParams} annotation.</p>
     *
     * @param context
     *          the {@link InvocationContext} from which all {@link FormParams} annotations applied 
     *          on the endpoint method will be extracted
     * <br><br>
     * @return an <b>unmodifiable</b> {@link List} which aggregates all the @{@link Param} annotations 
     *             found on the {@link FormParams} annotation
     * <br><br>
     * @throws NullPointerException
     *          if the supplied {@link InvocationContext} was {@code null}
     * <br><br>
     * @since 1.3.0
     */
    static List<Param> findStaticFormParams(InvocationContext context) {

        Method request = assertNotNull(context).getRequest();

        FormParams formParams = request.getAnnotation(FormParams.class);

        return Collections
                .unmodifiableList(formParams != null ? Arrays.asList(formParams.value()) : new ArrayList<Param>());
    }

    /**
     * <p>Finds all <b>static headers</b> in the given {@link InvocationContext} and returns an unmodifiable 
     * {@link List} of {@link Map.Entry} instances with the header <i>name</i> as the key and the runtime 
     * argument as the <i>value</i>.
     *  
     * <b>Note</b> that this implementation of {@link Map.Entry#setValue(Object)} throws an 
     * {@link UnsupportedOperationException}. This list may contain multiple entries with the <i>same name</i> 
     * as these headers are meant to be <b>added</b> ant not overwritten for a request.</p>
     * 
     * <p><i>Static-headers</i> are specified at request-level with @{@link Headers}</p>
     * 
     * <br><br>
     * @param context
     *          the {@link InvocationContext} from which all static headers will be discovered
     * <br><br>
     * @return an <b>unmodifiable</b> {@link List} of {@link Map.Entry} instances with the header <i>name</i> 
     *          as the key and the runtime argument as the <i>value</i>; <b>note</b> that this implementation 
     *          of {@link Map.Entry#setValue(Object)} hrows an {@link UnsupportedOperationException} 
     * <br><br>
     * @throws NullPointerException
     *          if the supplied {@link InvocationContext} was {@code null}
     * <br><br>
     * @since 1.3.0
     */
    static List<Map.Entry<String, Object>> findStaticHeaders(InvocationContext context) {

        assertNotNull(context);

        Method request = context.getRequest();
        Headers headerSet = request.getAnnotation(Headers.class);

        List<Map.Entry<String, Object>> headers = new ArrayList<Map.Entry<String, Object>>();

        if (headerSet != null && headerSet.value() != null && headerSet.value().length > 0) {

            List<Headers.Header> staticHeaders = Arrays.asList(headerSet.value());

            for (final Headers.Header staticHeader : staticHeaders) {

                headers.add(new Map.Entry<String, Object>() {

                    @Override
                    public String getKey() {
                        return staticHeader.name();
                    }

                    @Override
                    public Object getValue() {
                        return staticHeader.value();
                    }

                    @Override
                    public Object setValue(Object value) {
                        throw new UnsupportedOperationException();
                    }
                });
            }
        }

        return Collections.unmodifiableList(headers);
    }

    /**
     * <p>Retrieves the proper extension of {@link HttpRequestBase} for the given {@link InvocationContext}. 
     * This implementation is solely dependent upon the {@link RequestMethod} property in the annotated 
     * metdata of the endpoint method definition.</p>
     *
     * @param context
     *          the {@link InvocationContext} for which a {@link HttpRequestBase} is to be generated 
     * <br><br>
     * @return the {@link HttpRequestBase} translated from the {@link InvocationContext}'s {@link RequestMethod}
     * <br><br>
     * @throws NullPointerException
     *          if the supplied {@link InvocationContext} was {@code null} 
     * <br><br>
     * @since 1.3.0
     */
    static HttpRequestBase translateRequestMethod(InvocationContext context) {

        RequestMethod requestMethod = Metadata.findMethod(assertNotNull(context).getRequest());

        switch (requestMethod) {

        case POST:
            return new HttpPost();
        case PUT:
            return new HttpPut();
        case PATCH:
            return new HttpPatch();
        case DELETE:
            return new HttpDelete();
        case HEAD:
            return new HttpHead();
        case TRACE:
            return new HttpTrace();
        case OPTIONS:
            return new HttpOptions();

        case GET:
        default:
            return new HttpGet();
        }
    }
}