HttpPut Multi-part and handle https request.

Source

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"package com.karl.learn;



import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.math.BigInteger;

import java.security.KeyManagementException;

import java.security.KeyStore;

import java.security.KeyStoreException;

import java.security.NoSuchAlgorithmException;

import java.security.UnrecoverableKeyException;

import java.security.cert.CertificateException;



import javax.crypto.Cipher;

import javax.crypto.spec.SecretKeySpec;



import org.apache.http.HttpException;

import org.apache.http.client.HttpClient;

import org.apache.http.client.methods.HttpPut;

import org.apache.http.conn.scheme.PlainSocketFactory;

import org.apache.http.conn.scheme.Scheme;

import org.apache.http.conn.scheme.SchemeRegistry;

import org.apache.http.conn.ssl.SSLSocketFactory;

import org.apache.http.entity.InputStreamEntity;

import org.apache.http.impl.client.DefaultHttpClient;

import org.apache.http.impl.client.DefaultHttpRequestRetryHandler;

import org.apache.http.impl.conn.PoolingClientConnectionManager;

import org.apache.http.params.BasicHttpParams;

import org.apache.http.params.CoreConnectionPNames;

import org.apache.http.params.HttpParams;



public class HTTPClient {

    private static String TrustKeyStore = "/opt/ericsson/jboss_trust.keystore";

    private static String TrustKeyPass = "pass";

    private static SSLSocketFactory trustFactory = null;

    private static final String KEY = "jaas is the way";

    private static int timeout = 60;

    private static final String boundary = "frontier";

    private static String contentType = "multipart/mixed; boundary=\""

            + boundary + "\"";

    private static final String lineEnd = "\r\n";

    private static final String twoHyphens = "--";



    public static boolean HttpPut(String uri, String requestBody, File file)

            throws HttpException, FileNotFoundException, IOException {

        boolean httpsFlag = uri.toLowerCase().startsWith("https");

        HttpClient client = getDefaultHttpClient(httpsFlag, timeout);

        HttpPut method = new HttpPut(uri);

        method.addHeader("Content-Type", contentType);

        int maxBufferSize = 100 * 1024;

        InputStreamEntity body = buildAddContentBody(requestBody, file,

                maxBufferSize);

        method.setEntity(body);

        int resp = client.execute(method).getStatusLine().getStatusCode();

        client.getConnectionManager().shutdown();

        if (resp >= 200 && resp < 300) {

            return true;

        } else {

            return false;

        }

    }



    private static InputStreamEntity buildAddContentBody(String requestBody,

            File file, int maxBufferSize) throws IOException,

            FileNotFoundException {

        int bytesRead;

        int bytesAvailable;

        int bufferSize;

        OutputStream os = new ByteArrayOutputStream();



        StringBuilder builder = new StringBuilder(200);

        builder.append(twoHyphens + boundary + lineEnd);

        builder.append("Content-Type: application/xml");

        builder.append(lineEnd + lineEnd);

        builder.append(requestBody);

        builder.append(lineEnd + twoHyphens + boundary + lineEnd);

        builder.append("Content-Type: application/octet-stream");

        builder.append(lineEnd + lineEnd);



        os.write(builder.toString().getBytes());



        FileInputStream fileInputStream = new FileInputStream(file);

        bytesAvailable = fileInputStream.available();

        bufferSize = Math.min(bytesAvailable, maxBufferSize);

        byte[] bufferFile = new byte[bufferSize];



        bytesRead = fileInputStream.read(bufferFile, 0, bufferSize);

        while (bytesRead > 0) {

            os.write(bufferFile, 0, bufferSize);

            bytesAvailable = fileInputStream.available();

            bufferSize = Math.min(bytesAvailable, maxBufferSize);

            bytesRead = fileInputStream.read(bufferFile, 0, bufferSize);

        }

        os.write(lineEnd.getBytes());

        os.write((twoHyphens + boundary + twoHyphens + lineEnd).getBytes());

        fileInputStream.close();



        byte[] inBuffer = new byte[maxBufferSize];

        os.write(inBuffer);

        InputStream is = new ByteArrayInputStream(inBuffer);

        return new InputStreamEntity(is, -1);



    }



    private static String decode(String secret) {

        try {

            byte[] kbytes = KEY.getBytes();

            SecretKeySpec key = new SecretKeySpec(kbytes, "Blowfish");



            BigInteger n = new BigInteger(secret, 16);

            byte[] encoding = n.toByteArray();



            if (encoding.length % 8 != 0) {

                int length = encoding.length;

                int newLength = (length / 8 + 1) * 8;

                int pad = newLength - length;

                byte[] old = encoding;

                encoding = new byte[newLength];

                for (int i = old.length - 1; i >= 0; --i) {

                    encoding[(i + pad)] = old[i];

                }

            }



            Cipher cipher = Cipher.getInstance("Blowfish");

            cipher.init(2, key);

            byte[] decode = cipher.doFinal(encoding);

            return new String(decode);

        } catch (Exception e) {

            return secret;

        }

    }



    private static KeyStore loadKeyStore(String path, String passwd) {

        KeyStore keyStore = null;

        FileInputStream keyStoreIn = null;

        try {

            keyStoreIn = new FileInputStream(new File(path));

        } catch (FileNotFoundException e) {

            System.out.println("Failed to open keystore: " + e.toString());

            return null;

        }



        try {

            keyStore = KeyStore.getInstance(KeyStore.getDefaultType());

            keyStore.load(keyStoreIn, decode(passwd).toCharArray());

        } catch (KeyStoreException e) {

            System.out.println("Failed to declare keystore: " + e.toString());

        } catch (NoSuchAlgorithmException e) {

            System.out.println("Failed to load keystore: " + e.toString());

            ;

        } catch (CertificateException e) {

            System.out.println("Failed to load keystore: " + e.toString());

        } catch (IOException e) {

            System.out.println("Failed to load keystore: " + e.toString());

        } finally {

            try {

                keyStoreIn.close();

            } catch (IOException e) {

                System.out.println("Failed to close keystore: " + e.toString());

            }

        }



        return keyStore;

    }



    public static SSLSocketFactory getTrustSSLSocketFactory(String tsPath,

            String tsPass) {

        if (tsPath == null || tsPass == null) {

            System.out

                    .println("Failed to create SSLSocketFactory due to truststore path is null ");

            return null;

        }



        if (trustFactory == null || tsPath.equalsIgnoreCase(tsPath)

                || tsPass.equalsIgnoreCase(tsPass)) {

            KeyStore localTrustStore = loadKeyStore(tsPath, tsPass);

            if (localTrustStore == null) {

                System.out

                        .println("Failed to create SSLSocketFactory due to keystore is null ");

                return null;

            }



            try {

                trustFactory = new SSLSocketFactory(localTrustStore);

            } catch (KeyManagementException e) {

                System.out.println("Failed to create SSLSocketFactory: "

                        + e.toString());

            } catch (UnrecoverableKeyException e) {

                System.out.println("Failed to create SSLSocketFactory: "

                        + e.toString());

            } catch (NoSuchAlgorithmException e) {

                System.out.println("Failed to create SSLSocketFactory: "

                        + e.toString());

            } catch (KeyStoreException e) {

                System.out.println("Failed to create SSLSocketFactory: "

                        + e.toString());

            }

        }



        return trustFactory;

    }



    public static HttpClient getDefaultHttpClient(boolean httpsFlag,

            int timeoutInSecond) throws HttpException {



        HttpParams params = new BasicHttpParams();

        params.setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT,

                timeoutInSecond * 1000);

        params.setParameter(CoreConnectionPNames.SO_TIMEOUT,

                timeoutInSecond * 1000);



        SchemeRegistry schemeR = new SchemeRegistry();



        schemeR.register(new Scheme("http", 80, PlainSocketFactory

                .getSocketFactory()));

        if (httpsFlag) {

            SSLSocketFactory sslFactory = getTrustSSLSocketFactory(

                    TrustKeyPass, TrustKeyStore);

            if (sslFactory == null) {



                throw new HttpException("SSL Factory class is null");

            }

            schemeR.register(new Scheme("https", 8443, sslFactory));

        }



        PoolingClientConnectionManager pccm = new PoolingClientConnectionManager(

                schemeR);



        DefaultHttpClient client = new DefaultHttpClient(pccm, params);



        DefaultHttpRequestRetryHandler retryHandler = new DefaultHttpRequestRetryHandler(

                0, false);

        client.setHttpRequestRetryHandler(retryHandler);



        return client;

    }

}

pom.xml

<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/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>



    <groupId>com.karl.learn</groupId>

    <artifactId>TestProject</artifactId>

    <version>1.0</version>

    <packaging>jar</packaging>



    <name>TestProject</name>

    <url>http://maven.apache.org</url>



    <properties>

        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

    </properties>



    <dependencies>

        <dependency>

            <groupId>junit</groupId>

            <artifactId>junit</artifactId>

            <version>4.8.2</version>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.apache.httpcomponents</groupId>

            <artifactId>httpclient</artifactId>

            <version>4.2.1</version>

            <scope>compile</scope>

        </dependency>

    </dependencies>

</project>