Java tutorial
/* * Copyright IBM Corp. 2014 * * 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. */ package com.ibm.sbt.services.client; import java.io.File; import java.io.IOException; import java.io.InputStream; import java.io.UnsupportedEncodingException; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import org.apache.http.HttpEntity; import org.apache.http.HttpResponse; import org.apache.http.client.methods.HttpRequestBase; import org.apache.http.entity.ContentType; import org.apache.http.entity.mime.MultipartEntityBuilder; import org.apache.http.entity.mime.content.ByteArrayBody; import org.apache.http.entity.mime.content.ContentBody; import org.apache.http.entity.mime.content.FileBody; import org.apache.http.entity.mime.content.InputStreamBody; import org.apache.http.entity.mime.content.StringBody; import org.w3c.dom.Document; import org.w3c.dom.Node; import com.ibm.commons.util.io.json.JsonJavaArray; import com.ibm.commons.util.io.json.JsonJavaObject; import com.ibm.commons.xml.xpath.XPathExpression; import com.ibm.sbt.services.client.ClientService.Handler; import com.ibm.sbt.services.client.ClientService.HandlerInputStream; import com.ibm.sbt.services.client.ClientService.HandlerJson; import com.ibm.sbt.services.client.ClientService.HandlerString; import com.ibm.sbt.services.client.ClientService.HandlerXml; import com.ibm.sbt.services.client.base.AtomXPath; import com.ibm.sbt.services.client.base.BaseService; import com.ibm.sbt.services.endpoints.BasicEndpoint; import com.ibm.sbt.services.endpoints.Endpoint; import com.ibm.sbt.services.rest.atom.AtomEntry; import com.ibm.sbt.services.rest.atom.AtomFeed; /** * @author mwallace * */ public class Request { private BaseService baseService; private String method; private String serviceUrl; private Map<String, String> parameters = new HashMap<String, String>(); private Map<String, String> headers = new HashMap<String, String>(); private Handler handler = null; private Object body = null; private List<BodyPart> bodyParts = new ArrayList<Request.BodyPart>(); /** * Constructor for the Request class. * @param baseService An instance of BaseService * @param method The HTTP Method, i.e. GET ,POST * @param serviceUrl the Url of the resource */ public Request(BaseService baseService, String method, String serviceUrl) { if (baseService == null) { throw new IllegalStateException("BaseService must not be null."); } this.baseService = baseService; this.method = method; this.serviceUrl = serviceUrl; } /** * Method to set basic authentication. * @param user The username to authenticate with. * @param password The Password to authenticate with. * @return The Request Object. */ public Request basicAuth(String user, String password) { Endpoint endpoint = baseService.getEndpoint(); if (endpoint instanceof BasicEndpoint) { ((BasicEndpoint) endpoint).setUser(user); ((BasicEndpoint) endpoint).setPassword(password); } else { throw new IllegalStateException("The login method is only supported when using basic authentication."); } return this; } /** * Method to add a header to the request. * @param name The name of the header to add to the request, i.e Content-Type * @param value The value of the header * @return Request the Request object. */ public Request header(String name, String value) { this.headers.put(name.trim(), value); return this; } /** * Method to add a map of headers to the request. * @param headers A map of headers to add to the request * @return the Request object */ public Request headers(Map<String, String> headers) { if (headers != null) { for (Map.Entry<String, String> entry : headers.entrySet()) { header(entry.getKey(), entry.getValue()); } } return this; } /** * Method to add a URL parameter to the request. * @param name the name of URL parameter * @param value the value of the parameter * @return the Reuqest object */ public Request parameter(String name, String value) { this.parameters.put(name.trim(), value); return this; } /** * Method to add a map of URL parameters. * @param parameters the map of parameters to add to the request * @return the Request object */ public Request parameters(Map<String, String> parameters) { if (parameters != null) { for (Map.Entry<String, String> entry : parameters.entrySet()) { parameter(entry.getKey(), entry.getValue()); } } return this; } /** * Method to set the request input body. * @param body the request body to add to the request. * @param mimeType the Content type of the body i.e application/atom+xml * @return The Request object * @throws UnsupportedEncodingException */ public Request body(String body, String mimeType) throws UnsupportedEncodingException { this.body = body; this.headers.put("Content-Type", mimeType); return this; } /** * Method to set the request input body. * @param body the request body to add to the request. * @param mimeType the Content type of the body i.e application/atom+xml * @return The Request object * @throws UnsupportedEncodingException */ public Request body(InputStream body, String mimeType) throws UnsupportedEncodingException { this.body = body; this.headers.put("Content-Type", mimeType); return this; } /** * Method to build the request body in parts, or to add to the existing request body. * @param name * @param body * @param mimeType * @return * @throws UnsupportedEncodingException */ public Request bodyPart(String name, String body, String mimeType) throws UnsupportedEncodingException { bodyParts.add(new BodyPart(name, body, mimeType)); return this; } /** * Method to build the request body in parts, or to add to the existing request body. * @param name * @param file * @param mimeType * @return * @throws UnsupportedEncodingException */ public Request bodyPart(String name, File file, String mimeType) throws UnsupportedEncodingException { bodyParts.add(new BodyPart(name, file, mimeType)); return this; } /** * Method to build the request body in parts, or to add to the existing request body. * @param name * @param inputStream * @param mimeType * @return * @throws UnsupportedEncodingException */ public Request bodyPart(String name, InputStream inputStream, String mimeType) throws UnsupportedEncodingException { bodyParts.add(new BodyPart(name, inputStream, mimeType)); return this; } /** * Method to build the request body in parts, or to add to the existing request body. * @param name * @param byteArrayData * @param mimeType * @return * @throws UnsupportedEncodingException */ /* public Request bodyPart(String name, byte[] byteArrayData, String mimeType) throws UnsupportedEncodingException { bodyParts.add(new BodyPart(name, byteArrayData, mimeType)); return this; } */ /** * Method to retrieve the request body. * @return The request body */ public Object getBody() { if (body != null) { return body; } if (!bodyParts.isEmpty()) { MultipartEntityBuilder builder = MultipartEntityBuilder.create(); for (BodyPart bodyPart : bodyParts) { builder.addPart(bodyPart.getName(), bodyPart.getData()); } return builder.build(); } return null; } /** * Method to retrieve the reponse as an Object. * @return an Object representation of the reponse * @throws ClientServicesException */ public Response<Object> response() throws ClientServicesException { return response(handler, Object.class); } /** * Method to retrieve the response as JSON. * @return A JSON representation of the Response * @throws ClientServicesException */ public Response<JsonJavaObject> asJson() throws ClientServicesException { return response(new HandlerJson(), JsonJavaObject.class); } /** * Method to retrieve the response as a JSON Array. * @return A JSON Array representation of the response * @throws ClientServicesException */ public Response<JsonJavaArray> asJsonArray() throws ClientServicesException { return response(new HandlerJson(), JsonJavaArray.class); } /** * Method to retrieve the response as a String. * @return String representation of the response * @throws ClientServicesException */ public Response<String> asString() throws ClientServicesException { return response(new HandlerString(), String.class); } /** * Method to retrieve the response as XML. * @return an XML representation of the response * @throws ClientServicesException */ public Response<Node> asXml() throws ClientServicesException { return response(new HandlerXml(), Node.class); } /** * Method to retrieve the response as an Input Stream. * @return The response as an input stream * @throws ClientServicesException */ public Response<InputStream> asInputStream() throws ClientServicesException { return response(new HandlerInputStream(), InputStream.class); } /** * Method to retrieve the response as an Atom Entry. * @return The response as an Atom Entry * @throws ClientServicesException */ public Response<AtomEntry> asAtomEntry() throws ClientServicesException { return response(new HandlerAtomEntry(), AtomEntry.class); } /** * Method to get the response as an Atom Feed. * @return The response as an Atom Feed * @throws ClientServicesException */ public Response<AtomFeed> asAtomFeed() throws ClientServicesException { return response(new HandlerAtomFeed(), AtomFeed.class); } // // Internals // private <T> Response<T> response(Handler handler, Class<T> responseClass) throws ClientServicesException { if (ClientService.METHOD_GET.equals(method)) { return baseService.getClientService().get(serviceUrl, parameters, headers, handler); } else if (ClientService.METHOD_POST.equals(method)) { return baseService.getClientService().post(serviceUrl, parameters, headers, getBody(), handler); } else if (ClientService.METHOD_PUT.equals(method)) { return baseService.getClientService().put(serviceUrl, parameters, headers, getBody(), handler); } else if (ClientService.METHOD_DELETE.equals(method)) { return baseService.getClientService().delete(serviceUrl, parameters, headers, handler); } else if (ClientService.METHOD_DELETE_BODY.equals(method)) { return baseService.getClientService().delete(serviceUrl, parameters, headers, getBody(), handler); } else { throw new IllegalStateException("Unknown method: " + method); } } private class HandlerAtomEntry extends HandlerXml { @Override public Object parseContent(HttpRequestBase request, HttpResponse response, HttpEntity entity) throws ClientServicesException, IOException { Document document = (Document) super.parseContent(request, response, entity); return new AtomEntry(document); } } private class HandlerAtomFeed extends HandlerXml { @Override public Object parseContent(HttpRequestBase request, HttpResponse response, HttpEntity entity) throws ClientServicesException, IOException { Document document = (Document) super.parseContent(request, response, entity); return new AtomFeed(document); } } private XPathExpression getAtomXPath(Node node, boolean isFeed) { if (node instanceof Document) { return (XPathExpression) (isFeed ? AtomXPath.entry.getPath() : AtomXPath.singleEntry.getPath()); } else { return null; } } private class BodyPart { private final String name; private final ContentBody data; BodyPart(String name, String stringData, String mimeType) { this.name = name; this.data = new StringBody(stringData, ContentType.create(mimeType)); } BodyPart(String name, File fileData, String mimeType) { this.name = name; this.data = new FileBody(fileData, ContentType.create(mimeType)); } BodyPart(String name, InputStream inputStreamData, String mimeType) { this.name = name; this.data = new InputStreamBody(inputStreamData, ContentType.create(mimeType)); } BodyPart(String name, byte[] byteArrayData, String mimeType) { this.name = name; this.data = new ByteArrayBody(byteArrayData, ContentType.create(mimeType), name); } public final String getName() { return name; } public final ContentBody getData() { return data; } } /* private class BodyPart { private final String name; private final Object data; private final String mimeType; BodyPart(String name, Object data, String mimeType) { this.name = name; this.data = data; this.mimeType = mimeType; } public final String getName(){ return name; } public final String getMimeType(){ return mimeType; } public final Object getData(){ return data; } } */ }