Java: Reading Email & Attachments From Different Email Server Using Javamail API

Download required jar for java mail from here.

Code snippet

package com.pritom.src;

import com.sun.mail.imap.IMAPFolder;
import com.sun.mail.imap.SortTerm;

import javax.mail.*;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeBodyPart;
import javax.mail.search.*;
import java.io.File;
import java.util.*;

/**
 * @author PRITOM
 * @date 2016-11-25
 */
public class ReadEmailFromServer {
    public static void main(String[] args) {
        gmail();
        //bleep();
        //yahoo();;
        //office();
    }

    private static void office() {
        String PROTOCOL = "imaps", HOST = "outlook.office365.com", USER = "xxxxx@outlook.com",
                PASSWORD = "xxxxx", ENCRYPTION_TYPE = "tls", PORT = "993";
        readEmail(PROTOCOL, HOST, USER, PASSWORD, ENCRYPTION_TYPE, PORT);
    }

    private static void yahoo() {
        String PROTOCOL = "imaps", HOST = "mail.yahoo.com", USER = "xxxxx@yahoo.com",
                PASSWORD = "xxxxx", ENCRYPTION_TYPE = "tls", PORT = "993";
        readEmail(PROTOCOL, HOST, USER, PASSWORD, ENCRYPTION_TYPE, PORT);
    }

    private static void bleep() {
        String PROTOCOL = "imaps", HOST = "bleep.xxxxx.com", USER = "pritom@xxxxx.com",
                PASSWORD = "xxxxx", ENCRYPTION_TYPE = "tls", PORT = "993";
        readEmail(PROTOCOL, HOST, USER, PASSWORD, ENCRYPTION_TYPE, PORT);
    }

    private static void gmail() {
        String PROTOCOL = "imaps", HOST = "imap.gmail.com", USER = "xxxxx@gmail.com",
                PASSWORD = "xxxxx", ENCRYPTION_TYPE = "tls", PORT = "993";
        readEmail(PROTOCOL, HOST, USER, PASSWORD, ENCRYPTION_TYPE, PORT);
    }

    private static void readEmail(String PROTOCOL, String HOST, String USER, String PASSWORD, String ENCRYPTION_TYPE, String PORT) {
        Properties props = new Properties();
        props.setProperty("mail.store.protocol", PROTOCOL);
        if(ENCRYPTION_TYPE.length() > 0 && !ENCRYPTION_TYPE.equalsIgnoreCase("none")) {
            if(PROTOCOL.equalsIgnoreCase("imap")) {
                props.setProperty("mail.imap.socketFactory.class", "javax.net.ssl.SSLSocketFactory");
                props.setProperty("mail.imap.socketFactory.fallback", "false");
                props.setProperty("mail.imap.ssl.enable", "true");
                props.setProperty("mail.imap.socketFactory.port", PORT.length() > 0 ? PORT : "993");
                if(ENCRYPTION_TYPE.equalsIgnoreCase("tls")) {
                    props.setProperty("mail.imap.starttls.enable", "true");
                }
            }
            else if(PROTOCOL.equalsIgnoreCase("pop3")) {
                props.setProperty("mail.pop3.socketFactory.class", "javax.net.ssl.SSLSocketFactory");
                props.setProperty("mail.pop3.socketFactory.fallback", "false");
                props.setProperty("mail.pop3.ssl.enable", "true");
                props.setProperty("mail.pop3.socketFactory.port", PORT.length() > 0 ? PORT : "995");
                if(ENCRYPTION_TYPE.equalsIgnoreCase("tls")) {
                    props.setProperty("mail.pop3.starttls.enable", "true");
                }
            }
        }
        try {
            Session session = Session.getInstance(props, null);
            Store store = session.getStore();
            store.connect(HOST, USER, PASSWORD);
            printAllFolders(store);
            IMAPFolder inbox = (IMAPFolder) store.getFolder("INBOX");
            inbox.open(Folder.READ_ONLY);

            SortTerm[] sortTerms = new SortTerm[1];
            sortTerms[0] = SortTerm.ARRIVAL;
            Message[] messages = inbox.getSortedMessages(sortTerms, getSearchCriteria());

            int maxReadNumber = 1;
            int total = messages.length > maxReadNumber ? maxReadNumber : messages.length;
            println("\nTotal_Email = " + messages.length);
            boolean ascending = false;
            for (int index = 0; index < total; index++) {
                int message_index = ascending ? index : messages.length - index - 1;
                Message message = messages[message_index];
                String subject = message.getSubject();
                println("-------------------------------------------------------------------------------------------");
                println("-------------------------------------------------------------------------------------------");
                println("------------------" + (index + 1) + "/" + messages.length + "----------------------" + subject);
                println("-------------------------------------------------------------------------------------------");
                println("-------------------------------------------------------------------------------------------");
                printAllHeaders(message);
                if (message.getContent() instanceof String) {
                    println("\tContent---------------Type=" + message.getContentType());
                    String body = message.getContent().toString();
                    body = body.length() > 100 ? body.substring(0, 100) + "..." : body;
                    println("\t\t" + toSingleLine(body));
                }
                else {
                    Map output = processMultipart((Multipart) message.getContent());
                    Object[] keys = output.keySet().toArray();
                    for (int i = 0; i < keys.length; i++) {
                        println("\t" + keys[i].toString().toUpperCase() + "-------------------------------------------");
                        if (keys[i].toString() == "attachments") {
                            List attachments = (List) output.get("attachments");
                            for (int j = 0; j < attachments.size(); j++) {
                                Map attachment = (Map) attachments.get(j);
                                /* You can save attachments to your local machine by uncomment line below */
                                //String toFile = saveFileFromEmailAttachment(attachment);
                                //println("File_Saved_To=" + toFile);
                                println("\t\tFile_Name=" + attachment.get("fileName"));
                            }
                        }
                        else {
                            String body = output.get(keys[i].toString()).toString().trim();
                            body = body.length() > 100 ? body.substring(0, 100) + "..." : body;
                            println("\t\t[[[" + toSingleLine(body) + "]]]");
                        }
                    }
                }
                if (total == index + 1) {
                    println("-------------------------------------------------------------------------------------------");
                    println("-------------------------------------------------------------------------------------------");
                    println("-------------------------------------------------------------------------------------------");
                }
            }
            inbox.close(false);
            store.close();
        }
        catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    private static void printAllFolders(Store store) throws Exception {
        println("Folders:::");
        Folder[] folders = store.getDefaultFolder().list();
        for (Folder folder : folders) {
            println("\t" + folder.getFullName());
            for (Folder subFolder : folder.list()) {
                println("\t\t" + subFolder.getFullName());
            }
        }
    }

    private static void printAllHeaders(Message message) throws Exception {
        Enumeration enumeration = message.getAllHeaders();
        while (enumeration.hasMoreElements()) {
            Header header = (Header) enumeration.nextElement();
            boolean show = !header.getName().startsWith("X-") && !header.getName().equals("Received");
            show = show && !header.getName().startsWith("Authentication-") && !header.getName().startsWith("DKIM-");
            if (show) {
                println("\t" + header.getName() + "===" + toSingleLine(header.getValue()));
            }
        }
    }

    private static SearchTerm getSearchCriteria() throws Exception {
        if (true) {
            //return null;
            //return new FlagTerm(new Flags(Flags.Flag.SEEN), false);
            //return new MessageIDTerm("CAD-oc7fMFqioVurtMPnGm63mWAA51wELBaLhtm38zvthTv0+DQ@mail.gmail.com");
        }
        FlagTerm unread = new FlagTerm(new Flags(Flags.Flag.SEEN), false);
        FromTerm fromTerm = new FromTerm(new InternetAddress("pritomkucse@gmail.com"));

        Calendar cal = Calendar.getInstance();
        /* Set date to 1 day back from now */
        cal.roll(Calendar.DATE, false);
        ReceivedDateTerm latest = new ReceivedDateTerm(DateTerm.GT, cal.getTime());
        SearchTerm andTerm = new AndTerm(unread, latest);

        SearchTerm notFromTerm = new NotTerm(new FromTerm(new InternetAddress("black_listed_domain.com")));

        SubjectTerm subjectTerm = new SubjectTerm("Notable");
        OrTerm orTerm = new OrTerm(fromTerm, new OrTerm(andTerm, subjectTerm));
        AndTerm andTerm1 = new AndTerm(orTerm, notFromTerm);
        /**
         * (FROM_pritomkucse@gmail.com OR (NOT_REED AND YESTERDAY) OR SUBJECT_CONTAINS_Notable) AND NOT_FROM_*@black_listed_domain.com
         */

        /* Custom search term, actually download email from server then check (slow) */
        SearchTerm searchTerm = new SearchTerm() {
            @Override
            public boolean match(Message message) {
                try {
                    if (message.getSubject().contains("forwarding")) {
                        return true;
                    }
                }
                catch (MessagingException ex) {
                    ex.printStackTrace();
                }
                return false;
            }
        };

        return andTerm1;
    }

    private static String saveFileFromEmailAttachment(Map attachment) {
        try {
            File dir = createAndGetDirectory();
            String fileName = attachment.get("fileName").toString();
            File toFile = new File(dir, fileName);
            MimeBodyPart mimeBodyPart = (MimeBodyPart) attachment.get("mimeBodyPart");
            mimeBodyPart.saveFile(toFile);
            return toFile.getAbsolutePath();
        }
        catch (Exception e) {
            e.printStackTrace();
            return e.getMessage();
        }
    }

    private static File createAndGetDirectory() {
        File file = new File("attachments");
        if (!file.exists()) {
            file.mkdir();
        }
        return file;
    }

    private static Map processMultipart(Multipart multipart) throws Exception {
        Map output = new HashMap();
        output.put("html", "");
        output.put("text", "");
        List attachments = new ArrayList();

        for(int i = 0; i < multipart.getCount(); i++) {
            Map result = processBodyPart(multipart.getBodyPart(i));
            if (result != null) {
                if (result.containsKey("type")) {
                    if (result.get("type").toString().equalsIgnoreCase("html")) {
                        output.put("html", result.get("content").toString());
                    }
                    else if (result.get("type").toString().equalsIgnoreCase("text")) {
                        output.put("text", result.get("content").toString());
                    }
                    else if (result.get("type").toString().equalsIgnoreCase("attachment")) {
                        attachments.add(result);
                    }
                }
                if (result.containsKey("html")) {
                    output.put("html", result.get("html").toString());
                }
                if (result.containsKey("text")) {
                    output.put("text", result.get("text").toString());
                }
                if (result.containsKey("attachments")) {
                    List thisAttachments = (List) result.get("attachments");
                    for (int i2 = 0; i2 < thisAttachments.size(); i2++) {
                        attachments.add(thisAttachments.get(i2));
                    }
                }
            }
        }
        output.put("attachments", attachments);

        return output;
    }

    private static Map processBodyPart(BodyPart bodyPart) throws Exception {
        if(bodyPart.isMimeType("text/html") && bodyPart.getFileName() == null) {
            Map data = new HashMap();
            data.put("type", "html");
            data.put("content", bodyPart.getContent().toString());
            return data;
        }
        else if(bodyPart.isMimeType("text/plain") && bodyPart.getFileName() == null) {
            Map data = new HashMap();
            data.put("type", "text");
            data.put("content", bodyPart.getContent().toString());
            return data;
        }
        else if(Part.ATTACHMENT.equalsIgnoreCase(bodyPart.getDisposition()) && bodyPart.getFileName() != null) {
            try {
                Map map = new HashMap();
                map.put("type", "attachment");
                map.put("fileName", bodyPart.getFileName());
                String fileType = bodyPart.getContentType();
                map.put("fileType", fileType.contains(":") ? fileType.substring(0, fileType.indexOf(";")) : fileType);
                map.put("mimeBodyPart", bodyPart);
                return map;
            }
            catch (Exception ex) {
                println("Error_Content=" + bodyPart.getContentType());
                ex.printStackTrace();
            }
        }
        else if(bodyPart.getContentType().contains("multipart")) {
            Map o = processMultipart((Multipart) bodyPart.getContent());
            return o;
        }
        return null;
    }

    private static String toSingleLine(String str) throws Exception {
        return str.replaceAll("\\s+", " ");
    }

    private static void println(Object o) {
        System.out.println(o);
    }
}

Php read email & attachments from google using oauth

You can get access token & other details to perform this action:
http://pritomkumar.blogspot.com/2016/11/using-oauth-20-for-google-client-side.html

Code snippet to read email & attachments from google using oauth

<?php
session_start();
init();
if(isset($_GET["email_id"])) {
    email_details();
}
else if(isset($_GET["email_attachment"])) {
    email_attachment();
}
else {
    list_email();
}

function init() {
    $_SESSION["google_user_id"] = "11822454346345607576118";
    $_SESSION["access_token"] = "ya29.CjCgA8bf_BCrsdfsdfsdfsdf5orH3cvbMMzQY0RX8NUrbgpNhm9oXHyAAZ0WF3Jid4WwQ";

    /* Permissions to read email */
    $_SESSION["scope"] = "https://www.googleapis.com/auth/userinfo.profile"; /* User profile */
    $_SESSION["scope"] .= " https://www.googleapis.com/auth/gmail.readonly"; /* Read mail */
}

function email_attachment() {
    $id = $_GET["email_attachment"];
    $name = $_GET["name"];
    if (!file_exists("attachments")) {
        mkdir("attachments");
    }

    $apiUrl = "https://www.googleapis.com/gmail/v1/users/".$_SESSION["google_user_id"];
    $apiUrl .= "/messages/$id/attachments/".$id;
    $apiUrl .= "?access_token=".$_SESSION["access_token"];
    $remoteFile = decode_content(json_decode(make_request($apiUrl))->data);
    $file = "attachments/".md5(time()).$name;
    file_put_contents($file, $remoteFile);
    header("Location: $file");
    exit;
}

function email_details() {
    $id = $_GET["email_id"];
    $raw = "";// "format=raw&";
    $fields = "";// "fields=raw&";
    $apiUrl = "https://www.googleapis.com/gmail/v1/users/";
    $apiUrl .= $_SESSION["google_user_id"]."/messages/$id?$raw$fields";
    $apiUrl .= "access_token=".$_SESSION["access_token"];
    //echo $apiUrl; die();
    $result = json_decode(make_request($apiUrl));
    //file_put_contents("raw-email.txt", $result->raw); die();
    //echo "<pre>"; print_r($result); echo "</pre>"; die();

    $message = parse_email($result->payload->parts);
    $link = ""; $html = "";
    foreach($message as $msg) {
        if($msg["type"] == "html") {
            $html = $msg["body"];
        }
        else if($msg["type"] == "text") {
            //you can do anything with text part of email
        }
        else {
            $link .= "<a href='?email_attachment=".$msg["body"]."&name=".$msg["name"]."' target='_blank'>".$msg["name"]."</a><br/>";
        }
    }
    echo "<h3><i>Email Attachments:</i></h3>".$link."<h3><i>Email Body:</i></h3>".trim($html);
}

function parse_email($email) {
    $result = array();
    for($i = 0; $i < count($email); $i++) {
        $part = $email[$i];
        $mime = $part->mimeType;
        $name = $part->filename;
        if(strlen($name) > 0) {
            $file = array();
            $file["type"] = $mime;
            $file["name"] = $name;
            $file["body"] = $part->body->attachmentId;
            array_push($result, $file);
        }
        else if($mime === "text/plain") {
            $file = array();
            $file["type"] = "text";
            $file["name"] = "email_body_plain.html";
            $file["body"] = decode_content($part->body->data);
            array_push($result, $file);
        }
        else if($mime === "text/html") {
            $file = array();
            $file["type"] = "html";
            $file["name"] = "email_body_html.html";
            $file["body"] = decode_content($part->body->data);
            array_push($result, $file);
        }
        else if(substr($mime, 0, 9) === "multipart") {
            foreach(parse_email($part->parts) as $file) {
                array_push($result, $file);
            }
        }
    }
    return $result;
}

function decode_content($content) {
    return base64_decode(str_replace("-", "+", str_replace("_", "/", $content)));
}

function list_email() {
    //gmail api ref page: https://developers.google.com/gmail/api/v1/reference/
    //https://developers.google.com/gmail/api/v1/reference/users/messages/list
    //Searching filtering gmail over oauth2 api using php
    //https://developers.google.com/gmail/api/guides/filtering
    //https://support.google.com/mail/answer/7190?hl=en

    $search = "from:pritom@xxx.com OR from:pritomkucse@gmail.com"; //Search by from address
    $search = "subject:Fwd:"; //Words in the subject line
    $search = "label:sent OR label:starred"; //With certain labels
    $search = "has:attachment"; //Any email with attachments
    $search = "is:important"; //Important mails only
    $search = "is:read"; //For mails those are read already
    $search = "is:unread"; //For mails those are not read yet
    $search = "cc:pritomkucse@gmail.com"; //Emails has specific cc, bcc not allowed
    $search = "after:2016/11/19 AND label:inbox"; //Emails reached inbox after specific date
    $search = "before:2016/04/19 AND label:inbox"; //Emails reached inbox before specific date
    $search = "has:nouserlabels"; //Emails with no labels
    $search = "deliveredto:pritom@xxx.com"; //Emails delivered to some address
    $search = "size:10000"; //Email larger than bytes
    $search = "larger:15M"; //Emails larger than megabytes
    $search = "smaller:1M"; //Emails smaller than megabytes
    $search = "newer_than:1d"; //Emails newer than 1 day (d/m/y)
    $search = "older_than:20d"; //Emails older than 1 day (d/m/y)
    $search = "category:updates"; //Emails in specific category
    $search = "rfc822msgid:2021140448.450273.1479617087520.JavaMail.zimbra@bitmascot.com"; //Specific message by Message-ID
    $search = "!from:@gmail.com"; //Search by not from domain
    $search = "!from:pritomkucse@google.com"; //Search by not from address
    $search = ""; //No filtering

    $maxResults = 10;
    $apiUrl = "https://www.googleapis.com/gmail/v1/users/".$_SESSION["google_user_id"]."/messages?";
    $apiUrl .= "access_token=".$_SESSION["access_token"];
    $apiUrl .= "&maxResults=".$maxResults;
    if(strlen($search) > 0) {
        $apiUrl .= "&q=" . urlencode($search);
    }
    if(isset($_GET["next_page"]) && strlen($_GET["next_page"]) > 0) {
        $apiUrl .= "&pageToken=". $_GET["next_page"];
    }
    $result = json_decode(make_request($apiUrl));
    //echo "<pre>";print_r($result);echo "</pre>";die();

    if(isset($result->messages)) {
        foreach($result->messages as $m) {
            $link = "<a target='_blank' href='?email_id=".$m->id."'>View Message [[".$m->id . "]]</a><br/>";
            echo $link;
        }
    }
    else {
        echo "<pre>"; print_r($result); echo "</pre>"; die();
    }
    if(isset($result->nextPageToken)) {
        echo "<a href='?email=true&next_page=".$result->nextPageToken."'>Next_Page</a>";
    }
}

function make_request($url, $post = null, $headers = null, $returnArray = false) {
    $curl = curl_init();
    curl_setopt($curl, CURLOPT_URL, $url);
    curl_setopt($curl, CURLOPT_POST, $post == null ? 0 : 1);
    if($post != null) {
        curl_setopt($curl, CURLOPT_POSTFIELDS, $post);
    }
    curl_setopt($curl, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
    curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, false);
    curl_setopt($curl, CURLOPT_SSLVERSION, 1);
    if($headers != null) {
        curl_setopt($curl, CURLOPT_HEADER, true);
        curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
    }
    $response = curl_exec($curl);
    $http_code = curl_getinfo($curl, CURLINFO_HTTP_CODE);
    $header_size = curl_getinfo($curl, CURLINFO_HEADER_SIZE);
    curl_close($curl);
    if($http_code >= 400) {
        echo "Error executing request to Office365 api with error code=$http_code<br/><br/>\n\n";
        echo "<pre>"; print_r($response); echo "</pre>";
        die();
    }
    if($returnArray) {
        return array(
            "response" => $response,
            "header_size" => $header_size
        );
    }
    return $response;
}
?>

Java read email from google using oauth2 and parse email

Read Email From Google Account

package com.google_api;

import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;

/**
 * Created by pritom on 21/11/2016.
 */
public class JavaReadEmail extends JavaRawEmailParser {
    public static void main(String[] args) throws Exception {
        String accessToken = getAccessToken();
        String userID = "118224582562607576118"; /* From google profile */
        String messageID = "158855e85a035ed1";
        String url = "https://www.googleapis.com/gmail/v1/users/";
        url += userID + "/messages/" + messageID + "?format=raw";
        url += "&access_token=" + accessToken;

        HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();
        connection.setRequestMethod("GET");
        connection.setRequestProperty("Content-Type", "application/json");

        int httpCode = connection.getResponseCode();
        String responseMessage = connection.getResponseMessage(), httpResponse = "";
        InputStream is = null;
        if (httpCode >= 200 && httpCode <= 299) {
            is = connection.getInputStream();
        }
        else {
            is = connection.getErrorStream();
        }

        Writer writer5 = new StringWriter();
        char[] buffer = new char[1024];
        Reader reader = new BufferedReader(new InputStreamReader(is, "UTF-8"));
        int n;
        while ((n = reader.read(buffer)) != -1) {
            writer5.write(buffer, 0, n);
        }
        httpResponse = writer5.toString();
        println(httpResponse);

        String snippet = httpResponse.substring(httpResponse.indexOf("\"snippet\":") + 12);
        snippet = snippet.substring(0, snippet.indexOf("\n") - 2).trim();
        println("Snippet=" + snippet);

        String raw = httpResponse.substring(httpResponse.indexOf("\"raw\":") + 8);
        raw = raw.substring(0, raw.indexOf("\n") - 2).trim();

        parse(raw);
    }

    private static String getAccessToken() throws Exception {
        return "return access token from google";
    }
}

Parse Email Received From Google Account

package com.google_api;

import javax.mail.*;
import javax.mail.internet.MimeMessage;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.FileWriter;
import java.io.InputStream;
import java.util.*;

/**
 * Created by pritom on 20/11/2016.
 */
public class JavaRawEmailParser {
    private static final String ENCODING = "UTF-8";

    public static void parse(String rawEmail) throws Exception {
        rawEmail = Base64Decoder.decodeBase64(rawEmail);
        Session s = Session.getDefaultInstance(new Properties());
        InputStream is = new ByteArrayInputStream(rawEmail.getBytes(ENCODING));
        MimeMessage mimeMessage = new MimeMessage(s, is);
        Enumeration enumeration = mimeMessage.getAllHeaders();
        while (enumeration.hasMoreElements()) {
            Header header = (Header) enumeration.nextElement();
            if (!header.getName().contains("Received")) {
                println(header.getName() + " == " + toSingleLine(header.getValue()));
            }
        }
        Map output = processMultipart((Multipart) mimeMessage.getContent());
        for (Object key : output.keySet().toArray()) {
            println("Key=<<" + key + ">> == " + output.get(key));
        }
    }

    private static Map processMultipart(Multipart multipart) throws Exception {
        Map output = new HashMap();
        output.put("html", "");
        output.put("text", "");
        List attachments = new ArrayList();

        for(int i = 0; i < multipart.getCount(); i++) {
            Map result = processBodyPart(multipart.getBodyPart(i));
            if (result != null) {
                if (result.containsKey("type")) {
                    if (result.get("type").toString().equalsIgnoreCase("html")) {
                        output.put("html", result.get("content").toString());
                    }
                    else if (result.get("type").toString().equalsIgnoreCase("text")) {
                        output.put("text", result.get("content").toString());
                    }
                    else if (result.get("type").toString().equalsIgnoreCase("attachment")) {
                        attachments.add(result);
                    }
                }
                if (result.containsKey("html")) {
                    output.put("html", result.get("html").toString());
                }
                if (result.containsKey("text")) {
                    output.put("text", result.get("text").toString());
                }
                if (result.containsKey("attachments")) {
                    List thisAttachments = (List) result.get("attachments");
                    for (int i2 = 0; i2 < thisAttachments.size(); i2++) {
                        attachments.add(thisAttachments.get(i2));
                    }
                }
            }
        }
        output.put("attachments", attachments);

        return output;
    }

    private static Map processBodyPart(BodyPart bodyPart) throws Exception {
        if(bodyPart.isMimeType("text/html") && bodyPart.getFileName() == null) {
            Map data = new HashMap();
            data.put("type", "html");
            data.put("content", bodyPart.getContent().toString());
            return data;
        }
        else if(bodyPart.isMimeType("text/plain") && bodyPart.getFileName() == null) {
            Map data = new HashMap();
            data.put("type", "text");
            data.put("content", bodyPart.getContent().toString());
            return data;
        }
        else if(Part.ATTACHMENT.equalsIgnoreCase(bodyPart.getDisposition()) && bodyPart.getFileName() != null) {
            Map map = new HashMap();
            map.put("type", "attachment");
            map.put("fileName", bodyPart.getFileName());
            map.put("fileType", bodyPart.getContentType().substring(0, bodyPart.getContentType().indexOf(";")));
            map.put("mimeBodyPart", bodyPart);
            return map;
        }
        else if(bodyPart.getContentType().contains("multipart")) {
            Map o = processMultipart((Multipart) bodyPart.getContent());
            return o;
        }
        return null;
    }

    private static String toSingleLine(String str) throws Exception {
        return str.replaceAll("\\s+", " ");
    }

    private static void writeToFile(String location, String content) throws Exception {
        BufferedWriter out = new BufferedWriter(new FileWriter(location));
        out.write(content);
        out.close();
    }

    protected static void println(Object o) {
        System.out.println("" + o);
    }
}

Decode Util Class

package com.google_api;

/**
 * Created by pritom on 20/11/2016.
 */
public class Base64Decoder {
    private static final String ENCODING = "UTF-8";
    private static final byte[] CHUNK_SEPARATOR = new byte[]{(byte)13, (byte)10};
    private static final byte[] DECODE_TABLE = new byte[]{
            (byte)-1, (byte)-1, (byte)-1, (byte)-1, (byte)-1, (byte)-1, (byte)-1, (byte)-1, (byte)-1, (byte)-1,
            (byte)-1, (byte)-1, (byte)-1, (byte)-1, (byte)-1, (byte)-1, (byte)-1, (byte)-1, (byte)-1, (byte)-1,
            (byte)-1, (byte)-1, (byte)-1, (byte)-1, (byte)-1, (byte)-1, (byte)-1, (byte)-1, (byte)-1, (byte)-1,
            (byte)-1, (byte)-1, (byte)-1, (byte)-1, (byte)-1, (byte)-1, (byte)-1, (byte)-1, (byte)-1, (byte)-1,
            (byte)-1, (byte)-1, (byte)-1, (byte)62, (byte)-1, (byte)62, (byte)-1, (byte)63, (byte)52, (byte)53,
            (byte)54, (byte)55, (byte)56, (byte)57, (byte)58, (byte)59, (byte)60, (byte)61, (byte)-1, (byte)-1,
            (byte)-1, (byte)-1, (byte)-1, (byte)-1, (byte)-1, (byte)0, (byte)1, (byte)2, (byte)3, (byte)4, (byte)5,
            (byte)6, (byte)7, (byte)8, (byte)9, (byte)10, (byte)11, (byte)12, (byte)13, (byte)14, (byte)15, (byte)16,
            (byte)17, (byte)18, (byte)19, (byte)20, (byte)21, (byte)22, (byte)23, (byte)24, (byte)25, (byte)-1,
            (byte)-1, (byte)-1, (byte)-1, (byte)63, (byte)-1, (byte)26, (byte)27, (byte)28, (byte)29, (byte)30,
            (byte)31, (byte)32, (byte)33, (byte)34, (byte)35, (byte)36, (byte)37, (byte)38, (byte)39, (byte)40,
            (byte)41, (byte)42, (byte)43, (byte)44, (byte)45, (byte)46, (byte)47, (byte)48, (byte)49, (byte)50, (byte)51};
    private final byte[] decodeTable;
    private final int decodeSize;
    private int bitWorkArea;
    private byte[] buffer;
    private int pos;
    private int readPos;
    private boolean eof;
    private int modulus;

    public static String decodeBase64(String raw) throws Exception {
        return new String(new Base64Decoder(0, CHUNK_SEPARATOR).decode(raw), ENCODING);
    }

    private Base64Decoder(int lineLength, byte[] lineSeparator) throws Exception {
        super();
        this.decodeTable = DECODE_TABLE;
        int encodeSize;
        if(lineSeparator != null) {
            if(this.containsAlphabetOrPad(lineSeparator)) {
                String sep = newStringUtf8(lineSeparator);
                throw new Exception("lineSeparator must not contain base64 characters: [" + sep + "]");
            }

            if(lineLength > 0) {
                encodeSize = 4 + lineSeparator.length;
                System.arraycopy(lineSeparator, 0, new byte[lineSeparator.length], 0, lineSeparator.length);
            } else {
                encodeSize = 4;
            }
        } else {
            encodeSize = 4;
        }

        this.decodeSize = encodeSize - 1;
    }

    private void decode(byte[] in, int inPos, int inAvail) {
        if(!this.eof) {
            if(inAvail < 0) {
                this.eof = true;
            }

            for(int i = 0; i < inAvail; ++i) {
                this.ensureBufferSize(this.decodeSize);
                byte b = in[inPos++];
                if(b == 61) {
                    this.eof = true;
                    break;
                }

                if(b >= 0 && b < DECODE_TABLE.length) {
                    byte result = DECODE_TABLE[b];
                    if(result >= 0) {
                        this.modulus = (this.modulus + 1) % 4;
                        this.bitWorkArea = (this.bitWorkArea << 6) + result;
                        if(this.modulus == 0) {
                            this.buffer[this.pos++] = (byte)(this.bitWorkArea >> 16 & 255);
                            this.buffer[this.pos++] = (byte)(this.bitWorkArea >> 8 & 255);
                            this.buffer[this.pos++] = (byte)(this.bitWorkArea & 255);
                        }
                    }
                }
            }

            if(this.eof && this.modulus != 0) {
                this.ensureBufferSize(this.decodeSize);
                switch(this.modulus) {
                    case 2:
                        this.bitWorkArea >>= 4;
                        this.buffer[this.pos++] = (byte)(this.bitWorkArea & 255);
                        break;
                    case 3:
                        this.bitWorkArea >>= 2;
                        this.buffer[this.pos++] = (byte)(this.bitWorkArea >> 8 & 255);
                        this.buffer[this.pos++] = (byte)(this.bitWorkArea & 255);
                }
            }

        }
    }

    private boolean isInAlphabet(byte octet) {
        return octet >= 0 && octet < this.decodeTable.length && this.decodeTable[octet] != -1;
    }

    private int available() {
        return this.buffer != null ? this.pos - this.readPos : 0;
    }

    private int getDefaultBufferSize() {
        return 8192;
    }

    private void resizeBuffer() {
        if(this.buffer == null) {
            this.buffer = new byte[this.getDefaultBufferSize()];
            this.pos = 0;
            this.readPos = 0;
        }
        else {
            byte[] b = new byte[this.buffer.length * 2];
            System.arraycopy(this.buffer, 0, b, 0, this.buffer.length);
            this.buffer = b;
        }
    }

    private void ensureBufferSize(int size) {
        if(this.buffer == null || this.buffer.length < this.pos + size) {
            this.resizeBuffer();
        }

    }

    private int readResults(byte[] b, int bPos, int bAvail) {
        if(this.buffer != null) {
            int len = Math.min(this.available(), bAvail);
            System.arraycopy(this.buffer, this.readPos, b, bPos, len);
            this.readPos += len;
            if(this.readPos >= this.pos) {
                this.buffer = null;
            }
            return len;
        }
        else {
            return this.eof ? -1 : 0;
        }
    }

    private void reset() {
        this.buffer = null;
        this.pos = 0;
        this.readPos = 0;
        this.modulus = 0;
        this.eof = false;
    }

    private byte[] decode(String pArray) throws Exception {
        return this.decode(getBytesUtf8(pArray));
    }

    private byte[] decode(byte[] pArray) {
        this.reset();
        if(pArray != null && pArray.length != 0) {
            this.decode(pArray, 0, pArray.length);
            this.decode(pArray, 0, -1);
            byte[] result = new byte[this.pos];
            this.readResults(result, 0, result.length);
            return result;
        } else {
            return pArray;
        }
    }

    private boolean containsAlphabetOrPad(byte[] arrayOctet) {
        if(arrayOctet == null) {
            return false;
        }
        else {
            for (byte element : arrayOctet) {
                if (61 == element || this.isInAlphabet(element)) {
                    return true;
                }
            }
            return false;
        }
    }

    private static byte[] getBytesUtf8(String string) throws Exception {
        return getBytesUnchecked(string, "UTF-8");
    }

    private static byte[] getBytesUnchecked(String string, String charsetName) throws Exception {
        return string.getBytes(charsetName);
    }

    private static String newString(byte[] bytes, String charsetName) throws Exception {
        return new String(bytes, charsetName);
    }

    private static String newStringUtf8(byte[] bytes) throws Exception {
        return newString(bytes, "UTF-8");
    }
}

Output would be as like if your user id and message id is correct:

Snippet=Hello bro how are you?Some italic mode text
Return-Path == xxx@gmail.com
From == xxx@gmail.com
Reply-To == "Reply To" <some_reply_address@gmails.com>
MIME-Version == 1.0
Date == Mon, 21 Nov 2016 00:31:53 -0500
Subject == Test email on: 21/11/2016 06:31:44
To == "To Address" <xxx@xxx.com>
Content-Type == multipart/mixed; boundary="5258f110dfc605186344f1668864cea5"
Message-Id == <CAD-od7dd=JedEjLxQPLLTMwJ93ZSpWdwZHsWD_eL-Jr1M=iWWA@mail.gmail.com>
Key=<<attachments>> == [
	{fileName=My-pdf.pdf, mimeBodyPart=javax.mail.internet.MimeBodyPart@490ab905, type=attachment, fileType=application/pdf}, 
	{fileName=My-image.png, mimeBodyPart=javax.mail.internet.MimeBodyPart@56ac3a89, type=attachment, fileType=image/png}
]
Key=<<html>> == <b>Hello bro how are you?</b><i style='color:blue;'>Some italic mode text</i>
Key=<<text>> ==