camel-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From acosent...@apache.org
Subject [5/6] camel git commit: CAMEL-11056: Create new camel-olingo4 component for supporting OData 4.0
Date Fri, 24 Mar 2017 08:59:36 GMT
CAMEL-11056: Create new camel-olingo4 component for supporting OData 4.0

Project: http://git-wip-us.apache.org/repos/asf/camel/repo
Commit: http://git-wip-us.apache.org/repos/asf/camel/commit/e6eded4c
Tree: http://git-wip-us.apache.org/repos/asf/camel/tree/e6eded4c
Diff: http://git-wip-us.apache.org/repos/asf/camel/diff/e6eded4c

Branch: refs/heads/master
Commit: e6eded4c217b1734f36731396bff2f7fb9ee6f04
Parents: 46180b9
Author: Dmitry Volodin <dmvolod@gmail.com>
Authored: Thu Mar 23 15:48:32 2017 +0300
Committer: Andrea Cosentino <ancosen@gmail.com>
Committed: Fri Mar 24 09:49:39 2017 +0100

----------------------------------------------------------------------
 .../camel-olingo4/camel-olingo4-api/pom.xml     | 141 ++++
 .../camel/component/olingo4/api/Olingo4App.java | 145 ++++
 .../olingo4/api/Olingo4ResponseHandler.java     |  43 +
 .../api/batch/Olingo4BatchChangeRequest.java    | 103 +++
 .../api/batch/Olingo4BatchQueryRequest.java     |  76 ++
 .../olingo4/api/batch/Olingo4BatchRequest.java  |  44 +
 .../olingo4/api/batch/Olingo4BatchResponse.java |  63 ++
 .../component/olingo4/api/batch/Operation.java  |  39 +
 .../api/impl/AbstractFutureCallback.java        | 111 +++
 .../olingo4/api/impl/Olingo4AppImpl.java        | 841 +++++++++++++++++++
 .../src/main/resources/META-INF/LICENSE.txt     | 203 +++++
 .../src/main/resources/META-INF/NOTICE.txt      |  11 +
 .../component/olingo4/Olingo4AppAPITest.java    | 543 ++++++++++++
 .../src/test/resources/log4j2.properties        |  28 +
 .../camel-olingo4-component/pom.xml             | 191 +++++
 .../src/main/docs/olingo4-component.adoc        | 252 ++++++
 .../src/main/java/META-INF/MANIFEST.MF          |   3 +
 .../component/olingo4/Olingo4AppWrapper.java    | 108 +++
 .../component/olingo4/Olingo4Component.java     | 184 ++++
 .../component/olingo4/Olingo4Configuration.java | 221 +++++
 .../component/olingo4/Olingo4Consumer.java      |  92 ++
 .../component/olingo4/Olingo4Endpoint.java      | 222 +++++
 .../component/olingo4/Olingo4Producer.java      | 106 +++
 .../olingo4/internal/Olingo4Constants.java      |  29 +
 .../internal/Olingo4PropertiesHelper.java       |  39 +
 .../src/main/resources/META-INF/LICENSE.txt     | 203 +++++
 .../src/main/resources/META-INF/NOTICE.txt      |  11 +
 .../services/org/apache/camel/component/olingo4 |  18 +
 .../src/signatures/olingo-api-signature.txt     |   8 +
 .../olingo4/AbstractOlingo4TestSupport.java     | 104 +++
 .../component/olingo4/Olingo4ComponentTest.java | 264 ++++++
 .../src/test/resources/log4j2.properties        |  28 +
 components/camel-olingo4/pom.xml                |  38 +
 components/pom.xml                              |   1 +
 parent/pom.xml                                  |   1 +
 .../camel-olingo4-starter/pom.xml               |  67 ++
 .../Olingo4ComponentAutoConfiguration.java      | 111 +++
 .../Olingo4ComponentConfiguration.java          | 201 +++++
 .../src/main/resources/META-INF/LICENSE.txt     | 203 +++++
 .../src/main/resources/META-INF/NOTICE.txt      |  11 +
 ...dditional-spring-configuration-metadata.json |  10 +
 .../main/resources/META-INF/spring.factories    |  19 +
 .../src/main/resources/META-INF/spring.provides |  18 +
 .../spring-boot/components-starter/pom.xml      |   1 +
 44 files changed, 5155 insertions(+)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/camel/blob/e6eded4c/components/camel-olingo4/camel-olingo4-api/pom.xml
----------------------------------------------------------------------
diff --git a/components/camel-olingo4/camel-olingo4-api/pom.xml b/components/camel-olingo4/camel-olingo4-api/pom.xml
new file mode 100644
index 0000000..7f0495c
--- /dev/null
+++ b/components/camel-olingo4/camel-olingo4-api/pom.xml
@@ -0,0 +1,141 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Licensed to the Apache Software Foundation (ASF) under one or more contributor 
+  license agreements. See the NOTICE file distributed with this work for additional 
+  information regarding copyright ownership. The ASF licenses this file to 
+  You 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. -->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+  <modelVersion>4.0.0</modelVersion>
+
+  <parent>
+    <groupId>org.apache.camel</groupId>
+    <artifactId>camel-olingo4-parent</artifactId>
+    <version>2.19.0-SNAPSHOT</version>
+  </parent>
+
+  <artifactId>camel-olingo4-api</artifactId>
+  <name>Camel :: Olingo4 :: API</name>
+  <description>Camel Olingo4 API</description>
+  <packaging>jar</packaging>
+
+  <properties>
+    <camel.osgi.export.pkg>org.apache.camel.component.olingo4.api*</camel.osgi.export.pkg>
+  </properties>
+
+  <dependencies>
+    <dependency>
+      <groupId>org.apache.olingo</groupId>
+      <artifactId>odata-commons-api</artifactId>
+      <version>${olingo4-version}</version>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.olingo</groupId>
+      <artifactId>odata-commons-core</artifactId>
+      <version>${olingo4-version}</version>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.olingo</groupId>
+      <artifactId>odata-client-core</artifactId>
+      <version>${olingo4-version}</version>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.olingo</groupId>
+      <artifactId>odata-server-core</artifactId>
+      <version>${olingo4-version}</version>
+    </dependency>
+    
+    <dependency>
+      <groupId>org.apache.httpcomponents</groupId>
+      <artifactId>httpasyncclient</artifactId>
+    </dependency>
+    
+    <dependency>
+      <groupId>net.sf.jsignature.io-tools</groupId>
+      <artifactId>easystream</artifactId>
+      <version>1.2.15</version>
+    </dependency>
+
+    <!-- logging -->
+    <dependency>
+      <groupId>org.apache.logging.log4j</groupId>
+      <artifactId>log4j-api</artifactId>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.logging.log4j</groupId>
+      <artifactId>log4j-core</artifactId>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.logging.log4j</groupId>
+      <artifactId>log4j-slf4j-impl</artifactId>
+      <scope>test</scope>
+    </dependency>
+
+    <!-- testing -->
+    <dependency>
+      <groupId>org.apache.camel</groupId>
+      <artifactId>camel-test</artifactId>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <defaultGoal>install</defaultGoal>
+
+    <plugins>
+
+      <!-- to generate API Javadoc -->
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-javadoc-plugin</artifactId>
+        <executions>
+          <execution>
+            <id>add-javadoc</id>
+            <goals>
+              <goal>jar</goal>
+            </goals>
+            <configuration>
+              <attach>true</attach>
+              <source>${jdk.version}</source>
+              <quiet>true</quiet>
+              <detectOfflineLinks>false</detectOfflineLinks>
+              <javadocVersion>${jdk.version}</javadocVersion>
+              <encoding>UTF-8</encoding>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+
+    </plugins>
+  </build>
+
+  <!-- Disable Java 8 doclint checks to avoid Javadoc plugin failures -->
+  <profiles>
+    <profile>
+      <id>doclint-java8-disable</id>
+      <activation>
+        <jdk>[1.8,</jdk>
+      </activation>
+      <build>
+        <plugins>
+          <plugin>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-javadoc-plugin</artifactId>
+            <configuration>
+              <additionalparam>-Xdoclint:none</additionalparam>
+            </configuration>
+          </plugin>
+        </plugins>
+      </build>
+    </profile>
+  </profiles>
+
+</project>

http://git-wip-us.apache.org/repos/asf/camel/blob/e6eded4c/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/Olingo4App.java
----------------------------------------------------------------------
diff --git a/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/Olingo4App.java b/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/Olingo4App.java
new file mode 100644
index 0000000..95d42c2
--- /dev/null
+++ b/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/Olingo4App.java
@@ -0,0 +1,145 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.camel.component.olingo4.api;
+
+import java.io.InputStream;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.camel.component.olingo4.api.batch.Olingo4BatchResponse;
+import org.apache.olingo.commons.api.edm.Edm;
+import org.apache.olingo.commons.api.http.HttpStatusCode;
+
+/**
+ * Olingo4 Client Api Interface.
+ */
+public interface Olingo4App {
+
+    /**
+     * Sets Service base URI.
+     * @param serviceUri
+     */
+    void setServiceUri(String serviceUri);
+
+    /**
+     * Returns Service base URI.
+     * @return service base URI.
+     */
+    String getServiceUri();
+
+    /**
+     * Sets custom Http headers to add to every service request.
+     * @param httpHeaders custom Http headers.
+     */
+    void setHttpHeaders(Map<String, String> httpHeaders);
+
+    /**
+     * Returns custom Http headers.
+     * @return custom Http headers.
+     */
+    Map<String, String> getHttpHeaders();
+
+    /**
+     * Returns content type for service calls. Defaults to <code>application/json;charset=utf-8</code>.
+     * @return content type.
+     */
+    String getContentType();
+
+    /**
+     * Set default service call content type.
+     * @param contentType content type.
+     */
+    void setContentType(String contentType);
+
+    /**
+     * Closes resources.
+     */
+    void close();
+
+    /**
+     * Reads an OData resource and invokes callback with appropriate result.
+     * @param edm Service Edm, read from calling <code>read(null, "$metdata", null, responseHandler)</code>
+     * @param resourcePath OData Resource path
+     * @param queryParams OData query params
+     *                    http://docs.oasis-open.org/odata/odata/v4.0/odata-v4.0-part1-protocol.html#_Toc453752288
+     * @param responseHandler callback handler
+     */
+    <T> void read(Edm edm, String resourcePath, Map<String, String> queryParams, Olingo4ResponseHandler<T> responseHandler);
+
+    /**
+     * Reads an OData resource and invokes callback with the unparsed input stream.
+     * @param edm Service Edm, read from calling <code>read(null, "$metdata", null, responseHandler)</code>
+     * @param resourcePath OData Resource path
+     * @param queryParams OData query params
+     *                    http://docs.oasis-open.org/odata/odata/v4.0/odata-v4.0-part1-protocol.html#_Toc453752288
+     * @param responseHandler callback handler
+     */
+    void uread(Edm edm, String resourcePath, Map<String, String> queryParams,
+               Olingo4ResponseHandler<InputStream> responseHandler);
+
+    /**
+     * Deletes an OData resource and invokes callback
+     * with {@link org.apache.olingo.commons.api.http.HttpStatusCode} on success, or with exception on failure.
+     * @param resourcePath resource path for Entry
+     * @param responseHandler {@link org.apache.olingo.commons.api.http.HttpStatusCode} callback handler
+     */
+    void delete(String resourcePath, Olingo4ResponseHandler<HttpStatusCode> responseHandler);
+
+    /**
+     * Creates a new OData resource.
+     * @param edm service Edm
+     * @param resourcePath resource path to create
+     * @param data request data
+     * @param responseHandler callback handler
+     */
+    <T> void create(Edm edm, String resourcePath, Object data, Olingo4ResponseHandler<T> responseHandler);
+
+    /**
+     * Updates an OData resource.
+     * @param edm service Edm
+     * @param resourcePath resource path to update
+     * @param data updated data
+     * @param responseHandler {@link org.apache.olingo.client.api.domain.ClientEntity} callback handler
+     */
+    <T> void update(Edm edm, String resourcePath, Object data, Olingo4ResponseHandler<T> responseHandler);
+
+    /**
+     * Patches/merges an OData resource using HTTP PATCH.
+     * @param edm service Edm
+     * @param resourcePath resource path to update
+     * @param data patch/merge data
+     * @param responseHandler {@link org.apache.olingo.client.api.domain.ClientEntity} callback handler
+     */
+    <T> void patch(Edm edm, String resourcePath, Object data, Olingo4ResponseHandler<T> responseHandler);
+
+    /**
+     * Patches/merges an OData resource using HTTP MERGE.
+     * @param edm service Edm
+     * @param resourcePath resource path to update
+     * @param data patch/merge data
+     * @param responseHandler {@link org.apache.olingo.client.api.domain.ClientEntity} callback handler
+     */
+    <T> void merge(Edm edm, String resourcePath, Object data, Olingo4ResponseHandler<T> responseHandler);
+
+    /**
+     * Executes a batch request.
+     * @param edm service Edm
+     * @param data ordered {@link org.apache.camel.component.olingo4.api.batch.Olingo4BatchRequest} list
+     * @param responseHandler callback handler
+     */
+    void batch(Edm edm, Object data, Olingo4ResponseHandler<List<Olingo4BatchResponse>> responseHandler);
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/e6eded4c/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/Olingo4ResponseHandler.java
----------------------------------------------------------------------
diff --git a/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/Olingo4ResponseHandler.java b/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/Olingo4ResponseHandler.java
new file mode 100644
index 0000000..13438ba
--- /dev/null
+++ b/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/Olingo4ResponseHandler.java
@@ -0,0 +1,43 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.camel.component.olingo4.api;
+
+/**
+ * Callback interface to asynchronously process Olingo4 response.
+ */
+public interface Olingo4ResponseHandler<T> {
+
+    /**
+     * Handle response data on successful completion of Olingo4 request.
+     * @param response response data from Olingo4, may be NULL for Olingo4 operations with no response data.
+     */
+    void onResponse(T response);
+
+    /**
+     * Handle exception raised from Olingo4 request.
+     * @param ex exception from Olingo4 request.
+     * May be an instance of {@link org.apache.olingo.commons.api.ex.ODataException} or
+     * some other exception, such as {@link java.io.IOException}
+     */
+    void onException(Exception ex);
+
+    /**
+     * Handle Olingo4 request cancellation.
+     * May be caused by the underlying HTTP connection being shutdown asynchronously.
+     */
+    void onCanceled();
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/e6eded4c/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/batch/Olingo4BatchChangeRequest.java
----------------------------------------------------------------------
diff --git a/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/batch/Olingo4BatchChangeRequest.java b/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/batch/Olingo4BatchChangeRequest.java
new file mode 100644
index 0000000..5b4e1eb
--- /dev/null
+++ b/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/batch/Olingo4BatchChangeRequest.java
@@ -0,0 +1,103 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.camel.component.olingo4.api.batch;
+
+import java.util.Map;
+
+/**
+ * Batch Change part.
+ */
+public class Olingo4BatchChangeRequest extends Olingo4BatchRequest {
+
+    protected String contentId;
+    protected Operation operation;
+    protected Object body;
+
+    public Operation getOperation() {
+        return operation;
+    }
+
+    public Object getBody() {
+        return body;
+    }
+
+    public String getContentId() {
+        return contentId;
+    }
+
+    @Override
+    public String toString() {
+        return new StringBuilder("Batch Change Request{ ").append(resourceUri).append("/").append(resourcePath).append(", headers=").append(headers).append(", contentId=")
+            .append(contentId).append(", operation=").append(operation).append(", body=").append(body).append('}').toString();
+    }
+
+    public static Olingo4BatchChangeRequestBuilder resourcePath(String resourcePath) {
+        if (resourcePath == null) {
+            throw new IllegalArgumentException("resourcePath");
+        }
+        return new Olingo4BatchChangeRequestBuilder().resourcePath(resourcePath);
+    }
+
+    public static class Olingo4BatchChangeRequestBuilder {
+
+        private Olingo4BatchChangeRequest request = new Olingo4BatchChangeRequest();
+
+        public Olingo4BatchChangeRequestBuilder resourcePath(String resourcePath) {
+            request.resourcePath = resourcePath;
+            return this;
+        }
+
+        public Olingo4BatchChangeRequestBuilder resourceUri(String resourceUri) {
+            request.resourceUri = resourceUri;
+            return this;
+        }
+
+        public Olingo4BatchChangeRequestBuilder headers(Map<String, String> headers) {
+            request.headers = headers;
+            return this;
+        }
+
+        public Olingo4BatchChangeRequestBuilder contentId(String contentId) {
+            request.contentId = contentId;
+            return this;
+        }
+
+        public Olingo4BatchChangeRequestBuilder operation(Operation operation) {
+            request.operation = operation;
+            return this;
+        }
+
+        public Olingo4BatchChangeRequestBuilder body(Object body) {
+            request.body = body;
+            return this;
+        }
+
+        public Olingo4BatchChangeRequest build() {
+            // avoid later NPEs
+            if (request.resourcePath == null) {
+                throw new IllegalArgumentException("Null resourcePath");
+            }
+            if (request.operation == null) {
+                throw new IllegalArgumentException("Null operation");
+            }
+            if (request.operation != Operation.DELETE && request.body == null) {
+                throw new IllegalArgumentException("Null body");
+            }
+            return request;
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/e6eded4c/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/batch/Olingo4BatchQueryRequest.java
----------------------------------------------------------------------
diff --git a/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/batch/Olingo4BatchQueryRequest.java b/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/batch/Olingo4BatchQueryRequest.java
new file mode 100644
index 0000000..127a3ef
--- /dev/null
+++ b/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/batch/Olingo4BatchQueryRequest.java
@@ -0,0 +1,76 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.camel.component.olingo4.api.batch;
+
+import java.util.Map;
+
+/**
+ * Batch Query part.
+ */
+public class Olingo4BatchQueryRequest extends Olingo4BatchRequest {
+
+    private Map<String, String> queryParams;
+
+    public Map<String, String> getQueryParams() {
+        return queryParams;
+    }
+
+    public static Olingo4BatchQueryRequestBuilder resourcePath(String resourcePath) {
+        if (resourcePath == null) {
+            throw new IllegalArgumentException("resourcePath");
+        }
+        return new Olingo4BatchQueryRequestBuilder().resourcePath(resourcePath);
+    }
+
+    @Override
+    public String toString() {
+        return new StringBuilder("Batch Query Request{ ").append(resourceUri).append("/").append(resourcePath).append(", headers=").append(headers).append(", queryParams=")
+            .append(queryParams).append('}').toString();
+    }
+
+    public static class Olingo4BatchQueryRequestBuilder {
+        private Olingo4BatchQueryRequest request = new Olingo4BatchQueryRequest();
+
+        public Olingo4BatchQueryRequest build() {
+            // avoid later NPEs
+            if (request.resourcePath == null) {
+                throw new IllegalArgumentException("Null resourcePath");
+            }
+            return request;
+        }
+
+        public Olingo4BatchQueryRequestBuilder resourceUri(String resourceUri) {
+            request.resourceUri = resourceUri;
+            return this;
+        }
+
+        public Olingo4BatchQueryRequestBuilder resourcePath(String resourcePath) {
+            request.resourcePath = resourcePath;
+            return this;
+        }
+
+        public Olingo4BatchQueryRequestBuilder headers(Map<String, String> headers) {
+            request.headers = headers;
+            return this;
+        }
+
+        public Olingo4BatchQueryRequestBuilder queryParams(Map<String, String> queryParams) {
+            request.queryParams = queryParams;
+            return this;
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/e6eded4c/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/batch/Olingo4BatchRequest.java
----------------------------------------------------------------------
diff --git a/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/batch/Olingo4BatchRequest.java b/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/batch/Olingo4BatchRequest.java
new file mode 100644
index 0000000..8ad9568
--- /dev/null
+++ b/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/batch/Olingo4BatchRequest.java
@@ -0,0 +1,44 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.camel.component.olingo4.api.batch;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Base part in a multipart Batch request.
+ */
+public abstract class Olingo4BatchRequest {
+
+    protected String resourceUri;
+    protected String resourcePath;
+    protected Map<String, String> headers = new HashMap<String, String>();
+
+    public String getResourceUri() {
+        return resourceUri;
+    }
+    
+    public String getResourcePath() {
+        return resourcePath;
+    }
+
+    public Map<String, String> getHeaders() {
+        return headers;
+    }
+
+    public abstract String toString();
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/camel/blob/e6eded4c/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/batch/Olingo4BatchResponse.java
----------------------------------------------------------------------
diff --git a/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/batch/Olingo4BatchResponse.java b/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/batch/Olingo4BatchResponse.java
new file mode 100644
index 0000000..9d4ce91
--- /dev/null
+++ b/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/batch/Olingo4BatchResponse.java
@@ -0,0 +1,63 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.camel.component.olingo4.api.batch;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Batch Response part.
+ */
+public class Olingo4BatchResponse {
+
+    private final int statusCode;
+    private final String statusInfo;
+
+    private final String contentId;
+
+    private final Map<String, String> headers;
+    private final Object body;
+
+    public Olingo4BatchResponse(int statusCode, String statusInfo, String contentId, Map<String, String> headers, Object body) {
+        this.statusCode = statusCode;
+        this.statusInfo = statusInfo;
+        this.contentId = contentId;
+        this.headers = Collections.unmodifiableMap(new HashMap<String, String>(headers));
+        this.body = body;
+    }
+
+    public int getStatusCode() {
+        return statusCode;
+    }
+
+    public String getStatusInfo() {
+        return statusInfo;
+    }
+
+    public String getContentId() {
+        return contentId;
+    }
+
+    public Map<String, String> getHeaders() {
+        return headers;
+    }
+
+    public Object getBody() {
+        return body;
+    }
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/e6eded4c/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/batch/Operation.java
----------------------------------------------------------------------
diff --git a/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/batch/Operation.java b/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/batch/Operation.java
new file mode 100644
index 0000000..5785cae
--- /dev/null
+++ b/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/batch/Operation.java
@@ -0,0 +1,39 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.camel.component.olingo4.api.batch;
+
+/**
+* OData operation used by {@link org.apache.camel.component.olingo4.api.batch.Olingo4BatchChangeRequest}.
+*/
+public enum Operation {
+
+    CREATE("POST"),
+    UPDATE("PUT"),
+    PATCH("PATCH"),
+    MERGE("MERGE"),
+    DELETE("DELETE");
+
+    private final String httpMethod;
+
+    Operation(String httpMethod) {
+        this.httpMethod = httpMethod;
+    }
+
+    public String getHttpMethod() {
+        return httpMethod;
+    }
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/e6eded4c/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/impl/AbstractFutureCallback.java
----------------------------------------------------------------------
diff --git a/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/impl/AbstractFutureCallback.java b/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/impl/AbstractFutureCallback.java
new file mode 100644
index 0000000..1a206fa
--- /dev/null
+++ b/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/impl/AbstractFutureCallback.java
@@ -0,0 +1,111 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.camel.component.olingo4.api.impl;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.io.StringWriter;
+import java.util.regex.Pattern;
+
+import org.apache.camel.component.olingo4.api.Olingo4ResponseHandler;
+import org.apache.commons.io.IOUtils;
+import org.apache.http.HttpHeaders;
+import org.apache.http.HttpResponse;
+import org.apache.http.StatusLine;
+import org.apache.http.concurrent.FutureCallback;
+import org.apache.olingo.client.api.ODataClient;
+import org.apache.olingo.client.api.communication.ODataClientErrorException;
+import org.apache.olingo.client.api.serialization.ODataReader;
+import org.apache.olingo.client.core.ODataClientFactory;
+import org.apache.olingo.client.core.serialization.ODataReaderImpl;
+import org.apache.olingo.commons.api.ex.ODataError;
+import org.apache.olingo.commons.api.ex.ODataException;
+import org.apache.olingo.commons.api.format.ContentType;
+import org.apache.olingo.commons.api.http.HttpStatusCode;
+
+/**
+* Helper implementation of {@link org.apache.http.concurrent.FutureCallback}
+ * for {@link org.apache.camel.component.olingo4.api.impl.Olingo4AppImpl}
+*/
+public abstract class AbstractFutureCallback<T> implements FutureCallback<HttpResponse> {
+
+    public static final Pattern ODATA_MIME_TYPE_PATTERN = Pattern.compile("application/((atom)|(json)|(xml)).*");
+    public static final int NETWORK_CONNECT_TIMEOUT_ERROR = 599;
+    
+    private final Olingo4ResponseHandler<T> responseHandler;
+
+    AbstractFutureCallback(Olingo4ResponseHandler<T> responseHandler) {
+        this.responseHandler = responseHandler;
+    }
+
+    public static HttpStatusCode checkStatus(HttpResponse response) throws ODataException, ODataClientErrorException {
+        final StatusLine statusLine = response.getStatusLine();
+        HttpStatusCode httpStatusCode = HttpStatusCode.fromStatusCode(statusLine.getStatusCode());
+        if (HttpStatusCode.BAD_REQUEST.getStatusCode() <= httpStatusCode.getStatusCode() && httpStatusCode.getStatusCode() <= NETWORK_CONNECT_TIMEOUT_ERROR) {
+            if (response.getEntity() != null) {
+                try {
+                    final ContentType responseContentType = ContentType.parse(
+                        response.getFirstHeader(HttpHeaders.CONTENT_TYPE).getValue());
+                              
+                    if (ODATA_MIME_TYPE_PATTERN.matcher(responseContentType.toContentTypeString()).matches()) {
+                        final ODataReader reader = ODataClientFactory.getClient().getReader();
+                        final ODataError error = reader.readError(response.getEntity().getContent(), responseContentType);
+                        
+                        throw new ODataClientErrorException(statusLine, error);
+                    }
+                } catch (IOException e) {
+                    throw new ODataException(e.getMessage(), e);
+                }
+            }
+
+            throw new ODataException(statusLine.getReasonPhrase());
+        }
+
+        return httpStatusCode;
+    }
+
+    @Override
+    public final void completed(HttpResponse result) {
+        try {
+            // check response status
+            checkStatus(result);
+
+            onCompleted(result);
+        } catch (Exception e) {
+            failed(e);
+        } finally {
+            if (result instanceof Closeable) {
+                try {
+                    ((Closeable) result).close();
+                } catch (final IOException ignore) {
+                }
+            }
+        }
+    }
+
+    protected abstract void onCompleted(HttpResponse result) throws ODataException, IOException;
+
+    @Override
+    public final void failed(Exception ex) {
+        responseHandler.onException(ex);
+    }
+
+    @Override
+    public final void cancelled() {
+        responseHandler.onCanceled();
+    }
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/e6eded4c/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/impl/Olingo4AppImpl.java
----------------------------------------------------------------------
diff --git a/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/impl/Olingo4AppImpl.java b/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/impl/Olingo4AppImpl.java
new file mode 100644
index 0000000..7dffd1c
--- /dev/null
+++ b/components/camel-olingo4/camel-olingo4-api/src/main/java/org/apache/camel/component/olingo4/api/impl/Olingo4AppImpl.java
@@ -0,0 +1,841 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.camel.component.olingo4.api.impl;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.Closeable;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+import org.apache.camel.component.olingo4.api.Olingo4App;
+import org.apache.camel.component.olingo4.api.Olingo4ResponseHandler;
+import org.apache.camel.component.olingo4.api.batch.Olingo4BatchChangeRequest;
+import org.apache.camel.component.olingo4.api.batch.Olingo4BatchQueryRequest;
+import org.apache.camel.component.olingo4.api.batch.Olingo4BatchRequest;
+import org.apache.camel.component.olingo4.api.batch.Olingo4BatchResponse;
+import org.apache.camel.component.olingo4.api.batch.Operation;
+import org.apache.commons.io.IOUtils;
+import org.apache.commons.io.LineIterator;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.http.Consts;
+import org.apache.http.Header;
+import org.apache.http.HttpException;
+import org.apache.http.HttpHeaders;
+import org.apache.http.HttpResponse;
+import org.apache.http.HttpResponseFactory;
+import org.apache.http.HttpVersion;
+import org.apache.http.StatusLine;
+import org.apache.http.client.entity.DecompressingEntity;
+import org.apache.http.client.methods.CloseableHttpResponse;
+import org.apache.http.client.methods.HttpDelete;
+import org.apache.http.client.methods.HttpEntityEnclosingRequestBase;
+import org.apache.http.client.methods.HttpGet;
+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.HttpUriRequest;
+import org.apache.http.concurrent.FutureCallback;
+import org.apache.http.config.MessageConstraints;
+import org.apache.http.entity.AbstractHttpEntity;
+import org.apache.http.entity.ByteArrayEntity;
+import org.apache.http.impl.DefaultHttpResponseFactory;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClientBuilder;
+import org.apache.http.impl.client.HttpClients;
+import org.apache.http.impl.conn.DefaultHttpResponseParser;
+import org.apache.http.impl.io.HttpTransportMetricsImpl;
+import org.apache.http.impl.io.SessionInputBufferImpl;
+import org.apache.http.impl.nio.client.CloseableHttpAsyncClient;
+import org.apache.http.impl.nio.client.HttpAsyncClientBuilder;
+import org.apache.http.impl.nio.client.HttpAsyncClients;
+import org.apache.http.message.BasicLineParser;
+import org.apache.olingo.client.api.ODataBatchConstants;
+import org.apache.olingo.client.api.ODataClient;
+import org.apache.olingo.client.api.communication.request.ODataStreamer;
+import org.apache.olingo.client.api.communication.request.batch.ODataBatchLineIterator;
+import org.apache.olingo.client.api.domain.ClientEntity;
+import org.apache.olingo.client.api.domain.ClientPrimitiveValue;
+import org.apache.olingo.client.api.domain.ClientProperty;
+import org.apache.olingo.client.api.serialization.ODataReader;
+import org.apache.olingo.client.api.serialization.ODataWriter;
+import org.apache.olingo.client.api.uri.SegmentType;
+import org.apache.olingo.client.core.ODataClientFactory;
+import org.apache.olingo.client.core.communication.request.batch.ODataBatchController;
+import org.apache.olingo.client.core.communication.request.batch.ODataBatchLineIteratorImpl;
+import org.apache.olingo.client.core.communication.request.batch.ODataBatchUtilities;
+import org.apache.olingo.client.core.http.HttpMerge;
+import org.apache.olingo.commons.api.Constants;
+import org.apache.olingo.commons.api.edm.Edm;
+import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeKind;
+import org.apache.olingo.commons.api.edm.EdmReturnType;
+import org.apache.olingo.commons.api.edm.constants.ODataServiceVersion;
+import org.apache.olingo.commons.api.ex.ODataException;
+import org.apache.olingo.commons.api.format.ContentType;
+import org.apache.olingo.commons.api.http.HttpHeader;
+import org.apache.olingo.commons.api.http.HttpStatusCode;
+import org.apache.olingo.server.api.OData;
+import org.apache.olingo.server.api.uri.UriInfo;
+import org.apache.olingo.server.api.uri.UriInfoKind;
+import org.apache.olingo.server.api.uri.UriParameter;
+import org.apache.olingo.server.api.uri.UriResource;
+import org.apache.olingo.server.api.uri.UriResourceEntitySet;
+import org.apache.olingo.server.api.uri.UriResourceKind;
+import org.apache.olingo.server.core.uri.UriResourceFunctionImpl;
+import org.apache.olingo.server.core.uri.parser.Parser;
+import org.apache.olingo.server.core.uri.parser.UriParserException;
+import org.apache.olingo.server.core.uri.validator.UriValidationException;
+
+/**
+ * Application API used by Olingo4 Component.
+ */
+public final class Olingo4AppImpl implements Olingo4App {
+
+    private static final String SEPARATOR = "/";
+    private static final String BOUNDARY_PREFIX = "batch_";
+    private static final String BOUNDARY_PARAMETER = "; boundary=";
+    private static final String BOUNDARY_DOUBLE_DASH = "--";
+    private static final String MULTIPART_MIME_TYPE = "multipart/";
+    private static final String CONTENT_ID_HEADER = "Content-ID";
+    private static final String CLIENT_ENTITY_FAKE_MARKER = "('X')";
+
+    private static final ContentType DEFAULT_CONTENT_TYPE = ContentType.create(ContentType.APPLICATION_JSON, ContentType.PARAMETER_CHARSET, Constants.UTF8);
+    private static final ContentType METADATA_CONTENT_TYPE = ContentType.create(ContentType.APPLICATION_XML, ContentType.PARAMETER_CHARSET, Constants.UTF8);
+    private static final ContentType TEXT_PLAIN_WITH_CS_UTF_8 = ContentType.create(ContentType.TEXT_PLAIN, ContentType.PARAMETER_CHARSET, Constants.UTF8);
+    private static final ContentType SERVICE_DOCUMENT_CONTENT_TYPE = ContentType.APPLICATION_JSON;
+    private static final ContentType BATCH_CONTENT_TYPE = ContentType.MULTIPART_MIXED;
+
+    /**
+     * Reference to CloseableHttpAsyncClient (default) or CloseableHttpClient
+     */
+    private final Closeable client;
+
+    /**
+     * Reference to ODataClient reader and writer
+     */
+    private final ODataClient odataClient = ODataClientFactory.getClient();
+    private final ODataReader odataReader = odataClient.getReader();
+    private final ODataWriter odataWriter = odataClient.getWriter();
+
+    private String serviceUri;
+    private ContentType contentType;
+    private Map<String, String> httpHeaders;
+
+    /**
+     * Create Olingo4 Application with default HTTP configuration.
+     */
+    public Olingo4AppImpl(String serviceUri) {
+        // By default create HTTP asynchronous client
+        this(serviceUri, (HttpClientBuilder)null);
+    }
+
+    /**
+     * Create Olingo4 Application with custom HTTP Asynchronous client builder.
+     *
+     * @param serviceUri Service Application base URI.
+     * @param builder custom HTTP client builder.
+     */
+    public Olingo4AppImpl(String serviceUri, HttpAsyncClientBuilder builder) {
+        setServiceUri(serviceUri);
+
+        CloseableHttpAsyncClient asyncClient;
+        if (builder == null) {
+            asyncClient = HttpAsyncClients.createDefault();
+        } else {
+            asyncClient = builder.build();
+        }
+        asyncClient.start();
+        this.client = asyncClient;
+        this.contentType = DEFAULT_CONTENT_TYPE;
+    }
+
+    /**
+     * Create Olingo4 Application with custom HTTP Synchronous client builder.
+     *
+     * @param serviceUri Service Application base URI.
+     * @param builder Custom HTTP Synchronous client builder.
+     */
+    public Olingo4AppImpl(String serviceUri, HttpClientBuilder builder) {
+        setServiceUri(serviceUri);
+
+        if (builder == null) {
+            this.client = HttpClients.createDefault();
+        } else {
+            this.client = builder.build();
+        }
+        this.contentType = DEFAULT_CONTENT_TYPE;
+    }
+
+    @Override
+    public void setServiceUri(String serviceUri) {
+        if (serviceUri == null || serviceUri.isEmpty()) {
+            throw new IllegalArgumentException("serviceUri");
+        }
+        this.serviceUri = serviceUri.endsWith(SEPARATOR) ? serviceUri.substring(0, serviceUri.length() - 1) : serviceUri;
+    }
+
+    @Override
+    public String getServiceUri() {
+        return serviceUri;
+    }
+
+    @Override
+    public Map<String, String> getHttpHeaders() {
+        return httpHeaders;
+    }
+
+    @Override
+    public void setHttpHeaders(Map<String, String> httpHeaders) {
+        this.httpHeaders = httpHeaders;
+    }
+
+    @Override
+    public String getContentType() {
+        return contentType.toContentTypeString();
+    }
+
+    @Override
+    public void setContentType(String contentType) {
+        this.contentType = ContentType.parse(contentType);
+    }
+
+    @Override
+    public void close() {
+
+    }
+
+    @Override
+    public <T> void read(final Edm edm, final String resourcePath, final Map<String, String> queryParams, final Olingo4ResponseHandler<T> responseHandler) {
+        final String queryOptions = concatQueryParams(queryParams);
+        final UriInfo uriInfo = parseUri(edm, resourcePath, queryOptions);
+
+        execute(new HttpGet(createUri(resourcePath, queryOptions)), getResourceContentType(uriInfo), new AbstractFutureCallback<T>(responseHandler) {
+
+            @Override
+            public void onCompleted(HttpResponse result) throws IOException {
+                readContent(uriInfo, result.getEntity() != null ? result.getEntity().getContent() : null, responseHandler);
+            }
+
+        });
+    }
+
+    @Override
+    public void uread(final Edm edm, final String resourcePath, final Map<String, String> queryParams, final Olingo4ResponseHandler<InputStream> responseHandler) {
+        final String queryOptions = concatQueryParams(queryParams);
+        final UriInfo uriInfo = parseUri(edm, resourcePath, queryOptions);
+
+        execute(new HttpGet(createUri(resourcePath, queryOptions)), getResourceContentType(uriInfo), new AbstractFutureCallback<InputStream>(responseHandler) {
+
+            @Override
+            public void onCompleted(HttpResponse result) throws IOException {
+                InputStream responseStream = result.getEntity() != null ? result.getEntity().getContent() : null;
+                if (responseStream != null && result.getEntity() instanceof DecompressingEntity) {
+                    // In case of GZIP compression it's necessary to create
+                    // InputStream from the source byte array
+                    responseHandler.onResponse(new ByteArrayInputStream(IOUtils.toByteArray(responseStream)));
+                } else {
+                    responseHandler.onResponse(responseStream);
+                }
+            }
+        });
+    }
+
+    @Override
+    public <T> void create(Edm edm, String resourcePath, Object data, Olingo4ResponseHandler<T> responseHandler) {
+        final UriInfo uriInfo = parseUri(edm, resourcePath, null);
+
+        writeContent(edm, new HttpPost(createUri(resourcePath, null)), uriInfo, data, responseHandler);
+    }
+
+    @Override
+    public <T> void update(Edm edm, String resourcePath, Object data, Olingo4ResponseHandler<T> responseHandler) {
+        final UriInfo uriInfo = parseUri(edm, resourcePath, null);
+
+        writeContent(edm, new HttpPut(createUri(resourcePath, null)), uriInfo, data, responseHandler);
+    }
+
+    @Override
+    public void delete(String resourcePath, final Olingo4ResponseHandler<HttpStatusCode> responseHandler) {
+        execute(new HttpDelete(createUri(resourcePath)), contentType, new AbstractFutureCallback<HttpStatusCode>(responseHandler) {
+            @Override
+            public void onCompleted(HttpResponse result) {
+                final StatusLine statusLine = result.getStatusLine();
+                responseHandler.onResponse(HttpStatusCode.fromStatusCode(statusLine.getStatusCode()));
+            }
+        });
+    }
+
+    @Override
+    public <T> void patch(Edm edm, String resourcePath, Object data, Olingo4ResponseHandler<T> responseHandler) {
+        final UriInfo uriInfo = parseUri(edm, resourcePath, null);
+
+        writeContent(edm, new HttpPatch(createUri(resourcePath, null)), uriInfo, data, responseHandler);
+    }
+
+    @Override
+    public <T> void merge(Edm edm, String resourcePath, Object data, Olingo4ResponseHandler<T> responseHandler) {
+        final UriInfo uriInfo = parseUri(edm, resourcePath, null);
+
+        writeContent(edm, new HttpMerge(createUri(resourcePath, null)), uriInfo, data, responseHandler);
+    }
+
+    @Override
+    public void batch(Edm edm, Object data, Olingo4ResponseHandler<List<Olingo4BatchResponse>> responseHandler) {
+        final UriInfo uriInfo = parseUri(edm, SegmentType.BATCH.getValue(), null);
+
+        writeContent(edm, new HttpPost(createUri(SegmentType.BATCH.getValue(), null)), uriInfo, data, responseHandler);
+    }
+
+    private ContentType getResourceContentType(UriInfo uriInfo) {
+        ContentType resourceContentType;
+        switch (uriInfo.getKind()) {
+        case service:
+            // service document
+            resourceContentType = SERVICE_DOCUMENT_CONTENT_TYPE;
+            break;
+        case metadata:
+            // metadata
+            resourceContentType = METADATA_CONTENT_TYPE;
+            break;
+        case resource:
+            List<UriResource> listResource = uriInfo.getUriResourceParts();
+            UriResourceKind lastResourceKind = listResource.get(listResource.size() - 1).getKind();
+            // is it a $value or $count URI??
+            if (lastResourceKind == UriResourceKind.count || lastResourceKind == UriResourceKind.value) {
+                resourceContentType = TEXT_PLAIN_WITH_CS_UTF_8;
+            } else {
+                resourceContentType = contentType;
+            }
+            break;
+        default:
+            resourceContentType = contentType;
+        }
+        return resourceContentType;
+    }
+
+    private <T> void readContent(UriInfo uriInfo, InputStream content, Olingo4ResponseHandler<T> responseHandler) {
+        try {
+            responseHandler.onResponse(this.<T> readContent(uriInfo, content));
+        } catch (ODataException e) {
+            responseHandler.onException(e);
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private <T> T readContent(UriInfo uriInfo, InputStream content) throws ODataException {
+        T response = null;
+        switch (uriInfo.getKind()) {
+        case service:
+            // service document
+            response = (T)odataReader.readServiceDocument(content, SERVICE_DOCUMENT_CONTENT_TYPE);
+            break;
+
+        case metadata:
+            // $metadata
+            response = (T)odataReader.readMetadata(content);
+            break;
+        case resource:
+            // any resource entity
+            List<UriResource> listResource = uriInfo.getUriResourceParts();
+            UriResourceKind lastResourceKind = listResource.get(listResource.size() - 1).getKind();
+            switch (lastResourceKind) {
+            case entitySet:
+                UriResourceEntitySet uriResourceEntitySet = (UriResourceEntitySet)listResource.get(listResource.size() - 1);
+                List<UriParameter> keyPredicates = uriResourceEntitySet.getKeyPredicates();
+                // Check result type: single Entity or EntitySet based
+                // on key predicate detection
+                if (keyPredicates.size() == 1) {
+                    response = (T)odataReader.readEntity(content, getResourceContentType(uriInfo));
+                } else {
+                    response = (T)odataReader.readEntitySet(content, getResourceContentType(uriInfo));
+                }
+                break;
+            case count:
+                String stringCount = null;
+                try {
+                    stringCount = IOUtils.toString(content, Consts.UTF_8);
+                    response = (T)Long.valueOf(stringCount);
+                } catch (IOException e) {
+                    throw new ODataException("Error during $count value deserialization", e);
+                } catch (NumberFormatException e) {
+                    throw new ODataException("Error during $count value conversion: " + stringCount, e);
+                }
+                break;
+            case value:
+                try {
+                    ClientPrimitiveValue value = odataClient.getObjectFactory().newPrimitiveValueBuilder().setType(EdmPrimitiveTypeKind.String)
+                        .setValue(IOUtils.toString(content, Consts.UTF_8)).build();
+                    response = (T)value;
+                } catch (IOException e) {
+                    throw new ODataException("Error during $value deserialization", e);
+                }
+                break;
+            case primitiveProperty:
+            case complexProperty:
+                ClientProperty property = odataReader.readProperty(content, getResourceContentType(uriInfo));
+                if (property.hasPrimitiveValue()) {
+                    response = (T)property.getPrimitiveValue();
+                } else if (property.hasComplexValue()) {
+                    response = (T)property.getComplexValue();
+                } else {
+                    throw new ODataException("Unsupported property: " + property.getName());
+                }
+                break;
+            case function:
+                UriResourceFunctionImpl uriResourceFunction = (UriResourceFunctionImpl)listResource.get(listResource.size() - 1);
+                EdmReturnType functionReturnType = uriResourceFunction.getFunction().getReturnType();
+
+                switch (functionReturnType.getType().getKind()) {
+                case ENTITY:
+                    if (functionReturnType.isCollection()) {
+                        response = (T)odataReader.readEntitySet(content, getResourceContentType(uriInfo));
+                    } else {
+                        response = (T)odataReader.readEntity(content, getResourceContentType(uriInfo));
+                    }
+                    break;
+                case PRIMITIVE:
+                case COMPLEX:
+                    ClientProperty functionProperty = odataReader.readProperty(content, getResourceContentType(uriInfo));
+                    if (functionProperty.hasPrimitiveValue()) {
+                        response = (T)functionProperty.getPrimitiveValue();
+                    } else if (functionProperty.hasComplexValue()) {
+                        response = (T)functionProperty.getComplexValue();
+                    } else {
+                        throw new ODataException("Unsupported property: " + functionProperty.getName());
+                    }
+                    break;
+                default:
+                    throw new ODataException("Unsupported function return type " + uriInfo.getKind().name());
+                }
+                break;
+            default:
+                throw new ODataException("Unsupported resource type: " + lastResourceKind.name());
+            }
+            break;
+
+        default:
+            throw new ODataException("Unsupported resource type " + uriInfo.getKind().name());
+        }
+
+        return response;
+    }
+
+    private <T> void writeContent(final Edm edm, HttpEntityEnclosingRequestBase httpEntityRequest, final UriInfo uriInfo, final Object content,
+                                  final Olingo4ResponseHandler<T> responseHandler) {
+
+        try {
+            httpEntityRequest.setEntity(writeContent(edm, uriInfo, content));
+
+            final Header requestContentTypeHeader = httpEntityRequest.getEntity().getContentType();
+            final ContentType requestContentType = requestContentTypeHeader != null ? ContentType.parse(requestContentTypeHeader.getValue()) : contentType;
+
+            execute(httpEntityRequest, requestContentType, new AbstractFutureCallback<T>(responseHandler) {
+                @SuppressWarnings("unchecked")
+                @Override
+                public void onCompleted(HttpResponse result) throws IOException, ODataException {
+
+                    // if a entity is created (via POST request) the response
+                    // body contains the new created entity
+                    HttpStatusCode statusCode = HttpStatusCode.fromStatusCode(result.getStatusLine().getStatusCode());
+
+                    // look for no content, or no response body!!!
+                    final boolean noEntity = result.getEntity() == null || result.getEntity().getContentLength() == 0;
+                    if (statusCode == HttpStatusCode.NO_CONTENT || noEntity) {
+                        responseHandler.onResponse((T)HttpStatusCode.fromStatusCode(result.getStatusLine().getStatusCode()));
+                    } else {
+                        if (uriInfo.getKind() == UriInfoKind.resource) {
+                            List<UriResource> listResource = uriInfo.getUriResourceParts();
+                            UriResourceKind lastResourceKind = listResource.get(listResource.size() - 1).getKind();
+                            switch (lastResourceKind) {
+                            case entitySet:
+                                if (content instanceof ClientEntity) {
+                                    ClientEntity entity = odataReader.readEntity(result.getEntity().getContent(),
+                                                                                 ContentType.parse(result.getEntity().getContentType().getValue()));
+                                    responseHandler.onResponse((T)entity);
+                                } else {
+                                    throw new ODataException("Unsupported content type: " + content);
+                                }
+                                break;
+                            default:
+                                break;
+                            }
+                        } else if (uriInfo.getKind() == UriInfoKind.batch) {
+                            List<Olingo4BatchResponse> batchResponse = parseBatchResponse(edm, result, (List<Olingo4BatchRequest>)content);
+                            responseHandler.onResponse((T)batchResponse);
+                        } else {
+                            throw new ODataException("Unsupported resource type: " + uriInfo.getKind().name());
+                        }
+                    }
+                }
+            });
+
+        } catch (ODataException e) {
+            responseHandler.onException(e);
+        }
+    }
+
+    private AbstractHttpEntity writeContent(final Edm edm, final UriInfo uriInfo, final Object content) throws ODataException {
+        InputStream requestStream = null;
+        AbstractHttpEntity httpEntity = null;
+        if (uriInfo.getKind() == UriInfoKind.resource) {
+            // any resource entity
+            List<UriResource> listResource = uriInfo.getUriResourceParts();
+            UriResourceKind lastResourceKind = listResource.get(listResource.size() - 1).getKind();
+            switch (lastResourceKind) {
+            case entitySet:
+                if (content instanceof ClientEntity) {
+                    requestStream = odataWriter.writeEntity((ClientEntity)content, getResourceContentType(uriInfo));
+                } else {
+                    throw new ODataException("Unsupported content type: " + content);
+                }
+                break;
+            default:
+                throw new ODataException("Unsupported resource type: " + lastResourceKind);
+            }
+            try {
+                httpEntity = new ByteArrayEntity(IOUtils.toByteArray(requestStream));
+            } catch (IOException e) {
+                throw new ODataException("Error during converting input stream to byte array", e);
+            }
+            httpEntity.setChunked(false);
+
+        } else if (uriInfo.getKind() == UriInfoKind.batch) {
+            final String boundary = BOUNDARY_PREFIX + UUID.randomUUID();
+            final String contentHeader = BATCH_CONTENT_TYPE + BOUNDARY_PARAMETER + boundary;
+            final List<Olingo4BatchRequest> batchParts = (List<Olingo4BatchRequest>)content;
+
+            requestStream = serializeBatchRequest(edm, batchParts, BOUNDARY_DOUBLE_DASH + boundary);
+            try {
+                httpEntity = new ByteArrayEntity(IOUtils.toByteArray(requestStream));
+            } catch (IOException e) {
+                throw new ODataException("Error during converting input stream to byte array", e);
+            }
+            httpEntity.setChunked(false);
+            httpEntity.setContentType(contentHeader);
+        } else {
+            throw new ODataException("Unsupported resource type: " + uriInfo.getKind().name());
+        }
+
+        return httpEntity;
+    }
+
+    private InputStream serializeBatchRequest(final Edm edm, final List<Olingo4BatchRequest> batchParts, String boundary) throws ODataException {
+        final ByteArrayOutputStream batchRequestHeaderOutputStream = new ByteArrayOutputStream();
+
+        try {
+            batchRequestHeaderOutputStream.write(boundary.getBytes(Constants.UTF8));
+            batchRequestHeaderOutputStream.write(ODataStreamer.CRLF);
+
+            for (Olingo4BatchRequest batchPart : batchParts) {
+                writeHttpHeader(batchRequestHeaderOutputStream, HttpHeaders.CONTENT_TYPE, ContentType.APPLICATION_HTTP.toContentTypeString());
+                writeHttpHeader(batchRequestHeaderOutputStream, ODataBatchConstants.ITEM_TRANSFER_ENCODING_LINE, null);
+
+                if (batchPart instanceof Olingo4BatchQueryRequest) {
+                    final Olingo4BatchQueryRequest batchQueryPart = (Olingo4BatchQueryRequest)batchPart;
+                    final String batchQueryUri = createUri(StringUtils.isBlank(batchQueryPart.getResourceUri()) ? serviceUri : batchQueryPart.getResourceUri(),
+                                                           batchQueryPart.getResourcePath(), concatQueryParams(batchQueryPart.getQueryParams()));
+                    final UriInfo uriInfo = parseUri(edm, batchQueryPart.getResourcePath(), concatQueryParams(batchQueryPart.getQueryParams()));
+                    batchRequestHeaderOutputStream.write(ODataStreamer.CRLF);
+
+                    batchRequestHeaderOutputStream.write((HttpGet.METHOD_NAME + " " + batchQueryUri + " " + HttpVersion.HTTP_1_1).getBytes(Constants.UTF8));
+                    batchRequestHeaderOutputStream.write(ODataStreamer.CRLF);
+                    writeHttpHeader(batchRequestHeaderOutputStream, HttpHeaders.ACCEPT, getResourceContentType(uriInfo).toContentTypeString());
+
+                    batchRequestHeaderOutputStream.write(ODataStreamer.CRLF);
+                    batchRequestHeaderOutputStream.write(boundary.getBytes(Constants.UTF8));
+                    batchRequestHeaderOutputStream.write(ODataStreamer.CRLF);
+                } else if (batchPart instanceof Olingo4BatchChangeRequest) {
+                    final Olingo4BatchChangeRequest batchChangePart = (Olingo4BatchChangeRequest)batchPart;
+                    final String batchChangeUri = createUri(StringUtils.isBlank(batchChangePart.getResourceUri()) ? serviceUri : batchChangePart.getResourceUri(),
+                                                            batchChangePart.getResourcePath(), null);
+                    final UriInfo uriInfo = parseUri(edm, batchChangePart.getResourcePath(), null);
+
+                    if (batchChangePart.getOperation() != Operation.DELETE) {
+                        writeHttpHeader(batchRequestHeaderOutputStream, CONTENT_ID_HEADER, batchChangePart.getContentId());
+                    }
+
+                    batchRequestHeaderOutputStream.write(ODataStreamer.CRLF);
+                    batchRequestHeaderOutputStream
+                        .write((batchChangePart.getOperation().getHttpMethod() + " " + batchChangeUri + " " + HttpVersion.HTTP_1_1).getBytes(Constants.UTF8));
+                    batchRequestHeaderOutputStream.write(ODataStreamer.CRLF);
+                    writeHttpHeader(batchRequestHeaderOutputStream, HttpHeader.ODATA_VERSION, ODataServiceVersion.V40.toString());
+                    writeHttpHeader(batchRequestHeaderOutputStream, HttpHeaders.ACCEPT, getResourceContentType(uriInfo).toContentTypeString());
+                    writeHttpHeader(batchRequestHeaderOutputStream, HttpHeaders.CONTENT_TYPE, getResourceContentType(uriInfo).toContentTypeString());
+
+                    if (batchChangePart.getOperation() != Operation.DELETE) {
+                        batchRequestHeaderOutputStream.write(ODataStreamer.CRLF);
+                        AbstractHttpEntity httpEnity = writeContent(edm, uriInfo, batchChangePart.getBody());
+
+                        batchRequestHeaderOutputStream.write(IOUtils.toByteArray(httpEnity.getContent()));
+                        batchRequestHeaderOutputStream.write(ODataStreamer.CRLF);
+                        batchRequestHeaderOutputStream.write(ODataStreamer.CRLF);
+                    } else {
+                        batchRequestHeaderOutputStream.write(ODataStreamer.CRLF);
+                    }
+
+                    batchRequestHeaderOutputStream.write(boundary.getBytes(Constants.UTF8));
+                    batchRequestHeaderOutputStream.write(ODataStreamer.CRLF);
+                } else {
+                    throw new ODataException("Unsupported batch part request object type: " + batchPart);
+                }
+            }
+        } catch (Exception e) {
+            throw new ODataException("Error during batch request serialization", e);
+        }
+        return new ByteArrayInputStream(batchRequestHeaderOutputStream.toByteArray());
+    }
+
+    private void writeHttpHeader(ByteArrayOutputStream headerOutputStream, String headerName, String headerValue) throws IOException {
+        headerOutputStream.write(createHttpHeader(headerName, headerValue).getBytes(Constants.UTF8));
+        headerOutputStream.write(ODataStreamer.CRLF);
+    }
+
+    private String createHttpHeader(String headerName, String headerValue) {
+        return headerName + (StringUtils.isBlank(headerValue) ? "" : (": " + headerValue));
+    }
+
+    private List<Olingo4BatchResponse> parseBatchResponse(final Edm edm, HttpResponse response, List<Olingo4BatchRequest> batchRequest) throws ODataException {
+        List<Olingo4BatchResponse> batchResponse = new <Olingo4BatchResponse> ArrayList();
+        try {
+            final Header[] contentHeaders = response.getHeaders(HttpHeader.CONTENT_TYPE);
+            final ODataBatchLineIterator batchLineIterator = new ODataBatchLineIteratorImpl(IOUtils.lineIterator(response.getEntity().getContent(), Constants.UTF8));
+            final String batchBoundary = ODataBatchUtilities.getBoundaryFromHeader(getHeadersCollection(contentHeaders));
+            final ODataBatchController batchController = new ODataBatchController(batchLineIterator, batchBoundary);
+
+            batchController.getBatchLineIterator().next();
+            int batchRequestIndex = 0;
+            while (batchController.getBatchLineIterator().hasNext()) {
+                OutputStream os = new ByteArrayOutputStream();
+                ODataBatchUtilities.readBatchPart(batchController, os, false);
+                Object content = null;
+                final Olingo4BatchRequest batchPartRequest = (Olingo4BatchRequest)batchRequest.get(batchRequestIndex);
+                final HttpResponse batchPartHttpResponse = constructBatchPartHttpResponse(new ByteArrayInputStream(((ByteArrayOutputStream)os).toByteArray()));
+                final StatusLine batchPartStatusLine = batchPartHttpResponse.getStatusLine();
+                final int batchPartLineStatusCode = batchPartStatusLine.getStatusCode();
+                Map<String, String> batchPartHeaders = getHeadersValueMap(batchPartHttpResponse.getAllHeaders());
+                if (batchPartRequest instanceof Olingo4BatchQueryRequest) {
+                    Olingo4BatchQueryRequest batchPartQueryRequest = (Olingo4BatchQueryRequest)batchPartRequest;
+                    final UriInfo uriInfo = parseUri(edm, batchPartQueryRequest.getResourcePath(), null);
+
+                    if (HttpStatusCode.BAD_REQUEST.getStatusCode() <= batchPartLineStatusCode && batchPartLineStatusCode <= AbstractFutureCallback.NETWORK_CONNECT_TIMEOUT_ERROR) {
+                        final ContentType responseContentType = ContentType.parse(batchPartHttpResponse.getFirstHeader(HttpHeaders.CONTENT_TYPE).getValue());
+                        content = odataReader.readError(batchPartHttpResponse.getEntity().getContent(), responseContentType);
+                    } else if (batchPartLineStatusCode == HttpStatusCode.NO_CONTENT.getStatusCode()) {
+                        // nothing to do if NO_CONTENT returning
+                    } else {
+                        content = readContent(uriInfo, batchPartHttpResponse.getEntity().getContent());
+                    }
+
+                    Olingo4BatchResponse batchPartResponse = new Olingo4BatchResponse(batchPartStatusLine.getStatusCode(), batchPartStatusLine.getReasonPhrase(), null,
+                                                                                      batchPartHeaders, content);
+                    batchResponse.add(batchPartResponse);
+                } else if (batchPartRequest instanceof Olingo4BatchChangeRequest) {
+                    Olingo4BatchChangeRequest batchPartChangeRequest = (Olingo4BatchChangeRequest)batchPartRequest;
+
+                    if (batchPartLineStatusCode != HttpStatusCode.NO_CONTENT.getStatusCode()) {
+                        if (HttpStatusCode.BAD_REQUEST.getStatusCode() <= batchPartLineStatusCode
+                            && batchPartLineStatusCode <= AbstractFutureCallback.NETWORK_CONNECT_TIMEOUT_ERROR) {
+                            final ContentType responseContentType = ContentType.parse(batchPartHttpResponse.getFirstHeader(HttpHeaders.CONTENT_TYPE).getValue());
+                            content = odataReader.readError(response.getEntity().getContent(), responseContentType);
+                        } else {
+                            final UriInfo uriInfo = parseUri(edm, batchPartChangeRequest.getResourcePath()
+                                                                  + (batchPartChangeRequest.getOperation() == Operation.CREATE ? CLIENT_ENTITY_FAKE_MARKER : ""),
+                                                             null);
+                            content = readContent(uriInfo, batchPartHttpResponse.getEntity().getContent());
+                        }
+                    }
+                    Olingo4BatchResponse batchPartResponse = new Olingo4BatchResponse(batchPartStatusLine.getStatusCode(), batchPartStatusLine.getReasonPhrase(),
+                                                                                      batchPartChangeRequest.getContentId(), batchPartHeaders, content);
+                    batchResponse.add(batchPartResponse);
+                } else {
+                    throw new ODataException("Unsupported batch part request object type: " + batchPartRequest);
+                }
+                batchRequestIndex++;
+            }
+
+        } catch (IOException | HttpException e) {
+            throw new ODataException(e);
+        }
+        return batchResponse;
+    }
+
+    private HttpResponse constructBatchPartHttpResponse(InputStream batchPartStream) throws IOException, HttpException {
+        final LineIterator lines = IOUtils.lineIterator(batchPartStream, Constants.UTF8);
+        final ByteArrayOutputStream headerOutputStream = new ByteArrayOutputStream();
+        final ByteArrayOutputStream bodyOutputStream = new ByteArrayOutputStream();
+
+        boolean startBatchPartHeader = false;
+        boolean startBatchPartBody = false;
+
+        // Iterate through lines in the batch part
+        while (lines.hasNext()) {
+            String line = lines.nextLine().trim();
+            // Ignore all lines below HTTP/1.1 line
+            if (line.startsWith(HttpVersion.HTTP)) {
+                // This is the first header line
+                startBatchPartHeader = true;
+            }
+            // Body starts with empty string after header lines
+            if (startBatchPartHeader && StringUtils.isBlank(line)) {
+                startBatchPartHeader = false;
+                startBatchPartBody = true;
+            }
+            if (startBatchPartHeader) {
+                // Write header to the output stream
+                headerOutputStream.write(line.getBytes(Constants.UTF8));
+                headerOutputStream.write(ODataStreamer.CRLF);
+            } else if (startBatchPartBody && StringUtils.isNotBlank(line)) {
+                // Write body to the output stream
+                bodyOutputStream.write(line.getBytes(Constants.UTF8));
+                bodyOutputStream.write(ODataStreamer.CRLF);
+            }
+        }
+
+        // Prepare for parsing headers in to the HttpResponse object
+        HttpTransportMetricsImpl metrics = new HttpTransportMetricsImpl();
+        SessionInputBufferImpl sessionInputBuffer = new SessionInputBufferImpl(metrics, 2048);
+        HttpResponseFactory responseFactory = new DefaultHttpResponseFactory();
+
+        sessionInputBuffer.bind(new ByteArrayInputStream(headerOutputStream.toByteArray()));
+        DefaultHttpResponseParser responseParser = new DefaultHttpResponseParser(sessionInputBuffer, new BasicLineParser(), responseFactory, MessageConstraints.DEFAULT);
+
+        // Parse HTTP response and headers
+        HttpResponse response = responseParser.parse();
+        // Set body inside entity
+        response.setEntity(new ByteArrayEntity(bodyOutputStream.toByteArray()));
+
+        return response;
+    }
+
+    private Collection<String> getHeadersCollection(Header[] headers) {
+        Collection<String> headersCollection = new ArrayList();
+        for (Header header : Arrays.asList(headers)) {
+            headersCollection.add(header.getValue());
+        }
+        return headersCollection;
+    }
+
+    private Map<String, String> getHeadersValueMap(Header[] headers) {
+        Map<String, String> headersValueMap = new HashMap();
+        for (Header header : Arrays.asList(headers)) {
+            headersValueMap.put(header.getName(), header.getValue());
+        }
+        return headersValueMap;
+    }
+
+    private String createUri(String resourcePath) {
+        return createUri(serviceUri, resourcePath, null);
+    }
+
+    private String createUri(String resourcePath, String queryOptions) {
+        return createUri(serviceUri, resourcePath, queryOptions);
+    }
+
+    private String createUri(String resourceUri, String resourcePath, String queryOptions) {
+
+        final StringBuilder absolutUri = new StringBuilder(resourceUri).append(SEPARATOR).append(resourcePath);
+        if (queryOptions != null && !queryOptions.isEmpty()) {
+            absolutUri.append("/?" + queryOptions);
+        }
+        return absolutUri.toString();
+
+    }
+
+    private String concatQueryParams(final Map<String, String> queryParams) {
+        final StringBuilder concatQuery = new StringBuilder("");
+        if (queryParams != null && !queryParams.isEmpty()) {
+            int nParams = queryParams.size();
+            int index = 0;
+            for (Map.Entry<String, String> entry : queryParams.entrySet()) {
+                concatQuery.append(entry.getKey()).append('=').append(entry.getValue());
+                if (++index < nParams) {
+                    concatQuery.append('&');
+                }
+            }
+        }
+        return concatQuery.toString().replaceAll("  *", "%20");
+    }
+
+    private static UriInfo parseUri(Edm edm, String resourcePath, String queryOptions) {
+        Parser parser = new Parser(edm, OData.newInstance());
+        UriInfo result;
+
+        try {
+            result = parser.parseUri(resourcePath, queryOptions, null);
+        } catch (UriParserException | UriValidationException e) {
+            throw new IllegalArgumentException("parseUri (" + resourcePath + "," + queryOptions + "): " + e.getMessage(), e);
+        }
+        return result;
+    }
+
+    public void execute(HttpUriRequest httpUriRequest, ContentType contentType, FutureCallback<HttpResponse> callback) {
+        // add accept header when its not a form or multipart
+        final String contentTypeString = contentType.toString();
+        if (!ContentType.APPLICATION_FORM_URLENCODED.equals(contentType) && !contentType.toContentTypeString().startsWith(MULTIPART_MIME_TYPE)) {
+            // otherwise accept what is being sent
+            httpUriRequest.addHeader(HttpHeaders.ACCEPT, contentTypeString);
+        }
+
+        // is something being sent?
+        if (httpUriRequest instanceof HttpEntityEnclosingRequestBase && httpUriRequest.getFirstHeader(HttpHeaders.CONTENT_TYPE) == null) {
+            httpUriRequest.addHeader(HttpHeaders.CONTENT_TYPE, contentTypeString);
+        }
+
+        // set user specified custom headers
+        if (httpHeaders != null && !httpHeaders.isEmpty()) {
+            for (Map.Entry<String, String> entry : httpHeaders.entrySet()) {
+                httpUriRequest.setHeader(entry.getKey(), entry.getValue());
+            }
+        }
+
+        // add 'Accept-Charset' header to avoid BOM marker presents inside
+        // response stream
+        if (!httpUriRequest.containsHeader(HttpHeaders.ACCEPT_CHARSET)) {
+            httpUriRequest.addHeader(HttpHeaders.ACCEPT_CHARSET, Constants.UTF8);
+        }
+
+        // add client protocol version if not specified
+        if (!httpUriRequest.containsHeader(HttpHeader.ODATA_VERSION)) {
+            httpUriRequest.addHeader(HttpHeader.ODATA_VERSION, ODataServiceVersion.V40.toString());
+        }
+        if (!httpUriRequest.containsHeader(HttpHeader.ODATA_MAX_VERSION)) {
+            httpUriRequest.addHeader(HttpHeader.ODATA_MAX_VERSION, ODataServiceVersion.V40.toString());
+        }
+
+        // execute request
+        if (client instanceof CloseableHttpAsyncClient) {
+            ((CloseableHttpAsyncClient)client).execute(httpUriRequest, callback);
+        } else {
+            // invoke the callback methods explicitly after executing the
+            // request synchronously
+            try {
+                CloseableHttpResponse result = ((CloseableHttpClient)client).execute(httpUriRequest);
+                callback.completed(result);
+            } catch (IOException e) {
+                callback.failed(e);
+            }
+        }
+    }
+}


Mime
View raw message