MACRO NEPAL
POP3/IMAP Email Reader in Java
awiskar acharya
November 9, 2025
2:37 pm

Overview

A comprehensive email reader implementation supporting both POP3 and IMAP protocols with features for reading, searching, and processing emails.

Dependencies

Maven Dependencies

<dependencies>
<!-- JavaMail API -->
<dependency>
<groupId>com.sun.mail</groupId>
<artifactId>javax.mail</artifactId>
<version>1.6.2</version>
</dependency>
<!-- Apache Commons -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.12.0</version>
</dependency>
<!-- Logging -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.36</version>
</dependency>
<!-- JSON Processing -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.14.2</version>
</dependency>
</dependencies>

Core Implementation

1. Configuration Classes

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import java.util.Properties;
@JsonIgnoreProperties(ignoreUnknown = true)
public class EmailConfig {
private String protocol; // "pop3", "imap", "imaps"
private String host;
private int port;
private String username;
private String password;
private boolean useSSL;
private boolean useTLS;
private int connectionTimeout = 30000;
private int readTimeout = 30000;
private int batchSize = 50;
// Default configurations for common providers
public static EmailConfig gmailImapConfig(String username, String password) {
EmailConfig config = new EmailConfig();
config.setProtocol("imaps");
config.setHost("imap.gmail.com");
config.setPort(993);
config.setUsername(username);
config.setPassword(password);
config.setUseSSL(true);
config.setUseTLS(true);
return config;
}
public static EmailConfig outlookImapConfig(String username, String password) {
EmailConfig config = new EmailConfig();
config.setProtocol("imaps");
config.setHost("outlook.office365.com");
config.setPort(993);
config.setUsername(username);
config.setPassword(password);
config.setUseSSL(true);
config.setUseTLS(true);
return config;
}
public static EmailConfig yahooPop3Config(String username, String password) {
EmailConfig config = new EmailConfig();
config.setProtocol("pop3");
config.setHost("pop.mail.yahoo.com");
config.setPort(995);
config.setUsername(username);
config.setPassword(password);
config.setUseSSL(true);
return config;
}
public Properties toJavaMailProperties() {
Properties props = new Properties();
// Set protocol-specific properties
String protocol = this.protocol.toLowerCase();
props.put("mail." + protocol + ".host", host);
props.put("mail." + protocol + ".port", String.valueOf(port));
// Authentication
props.put("mail." + protocol + ".auth", "true");
// SSL/TLS configuration
if (useSSL) {
props.put("mail." + protocol + ".ssl.enable", "true");
props.put("mail." + protocol + ".ssl.trust", host);
}
if (useTLS) {
props.put("mail." + protocol + ".starttls.enable", "true");
}
// Timeout settings
props.put("mail." + protocol + ".connectiontimeout", String.valueOf(connectionTimeout));
props.put("mail." + protocol + ".timeout", String.valueOf(readTimeout));
// IMAP-specific properties
if (protocol.startsWith("imap")) {
props.put("mail.imap.partialfetch", "false");
props.put("mail.imap.fetchsize", "8192");
props.put("mail.imap.peek", "true"); // Don't set seen flag when reading
}
// POP3-specific properties
if (protocol.startsWith("pop3")) {
props.put("mail.pop3.rsetbeforequit", "true");
}
return props;
}
// Getters and setters
public String getProtocol() { return protocol; }
public void setProtocol(String protocol) { this.protocol = protocol; }
public String getHost() { return host; }
public void setHost(String host) { this.host = host; }
public int getPort() { return port; }
public void setPort(int port) { this.port = port; }
public String getUsername() { return username; }
public void setUsername(String username) { this.username = username; }
public String getPassword() { return password; }
public void setPassword(String password) { this.password = password; }
public boolean isUseSSL() { return useSSL; }
public void setUseSSL(boolean useSSL) { this.useSSL = useSSL; }
public boolean isUseTLS() { return useTLS; }
public void setUseTLS(boolean useTLS) { this.useTLS = useTLS; }
public int getConnectionTimeout() { return connectionTimeout; }
public void setConnectionTimeout(int connectionTimeout) { 
this.connectionTimeout = connectionTimeout; 
}
public int getReadTimeout() { return readTimeout; }
public void setReadTimeout(int readTimeout) { this.readTimeout = readTimeout; }
public int getBatchSize() { return batchSize; }
public void setBatchSize(int batchSize) { this.batchSize = batchSize; }
@Override
public String toString() {
return String.format(
"EmailConfig{protocol='%s', host='%s', port=%d, username='%s', useSSL=%s, useTLS=%s}",
protocol, host, port, username, useSSL, useTLS
);
}
}

2. Email Message Model

import javax.mail.Address;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Multipart;
import javax.mail.Part;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeUtility;
import java.io.IOException;
import java.util.*;
import java.util.regex.Pattern;
public class EmailMessage {
private String messageId;
private String subject;
private String from;
private List<String> to;
private List<String> cc;
private List<String> bcc;
private Date sentDate;
private Date receivedDate;
private String plainText;
private String htmlText;
private List<EmailAttachment> attachments;
private Map<String, String> headers;
private int messageNumber;
private long size;
private boolean seen;
private boolean replied;
private boolean deleted;
private List<String> flags;
public EmailMessage() {
this.to = new ArrayList<>();
this.cc = new ArrayList<>();
this.bcc = new ArrayList<>();
this.attachments = new ArrayList<>();
this.headers = new HashMap<>();
this.flags = new ArrayList<>();
}
public static EmailMessage fromMimeMessage(Message message) throws EmailProcessingException {
EmailMessage email = new EmailMessage();
try {
// Basic message info
email.setMessageNumber(message.getMessageNumber());
email.setMessageId(getMessageId(message));
email.setSubject(decodeText(message.getSubject()));
email.setSentDate(message.getSentDate());
email.setReceivedDate(message.getReceivedDate());
email.setSize(message.getSize());
// Address information
email.setFrom(extractAddress(message.getFrom()));
email.setTo(extractAddresses(message.getRecipients(Message.RecipientType.TO)));
email.setCc(extractAddresses(message.getRecipients(Message.RecipientType.CC)));
email.setBcc(extractAddresses(message.getRecipients(Message.RecipientType.BCC)));
// Flags
email.setSeen(message.isSet(Flags.Flag.SEEN));
email.setReplied(message.isSet(Flags.Flag.ANSWERED));
email.setDeleted(message.isSet(Flags.Flag.DELETED));
email.setFlags(extractFlags(message.getFlags()));
// Headers
email.setHeaders(extractHeaders(message));
// Content
extractContent(message, email);
} catch (Exception e) {
throw new EmailProcessingException("Failed to parse email message", e);
}
return email;
}
private static void extractContent(Part part, EmailMessage email) 
throws MessagingException, IOException {
Object content = part.getContent();
if (content instanceof String) {
// Simple text content
String text = (String) content;
if (part.isMimeType("text/plain")) {
email.setPlainText(text);
} else if (part.isMimeType("text/html")) {
email.setHtmlText(text);
}
} else if (content instanceof Multipart) {
// Multipart content
Multipart multipart = (Multipart) content;
for (int i = 0; i < multipart.getCount(); i++) {
BodyPart bodyPart = multipart.getBodyPart(i);
// Check for attachments
if (Part.ATTACHMENT.equalsIgnoreCase(bodyPart.getDisposition()) ||
bodyPart.getFileName() != null) {
EmailAttachment attachment = extractAttachment(bodyPart);
if (attachment != null) {
email.getAttachments().add(attachment);
}
} else {
// Recursively process nested parts
extractContent(bodyPart, email);
}
}
}
}
private static EmailAttachment extractAttachment(BodyPart bodyPart) 
throws MessagingException, IOException {
String fileName = bodyPart.getFileName();
if (fileName == null) return null;
fileName = decodeText(fileName);
EmailAttachment attachment = new EmailAttachment();
attachment.setFileName(fileName);
attachment.setContentType(bodyPart.getContentType());
attachment.setSize(bodyPart.getSize());
// For large attachments, we might want to stream instead of loading into memory
if (bodyPart.getSize() < 10 * 1024 * 1024) { // 10MB limit
attachment.setData(bodyPart.getInputStream().readAllBytes());
}
return attachment;
}
private static String extractAddress(Address[] addresses) {
if (addresses == null || addresses.length == 0) return null;
return decodeText(addresses[0].toString());
}
private static List<String> extractAddresses(Address[] addresses) {
List<String> result = new ArrayList<>();
if (addresses != null) {
for (Address address : addresses) {
result.add(decodeText(address.toString()));
}
}
return result;
}
private static List<String> extractFlags(Flags flags) {
List<String> result = new ArrayList<>();
if (flags != null) {
Flags.Flag[] systemFlags = flags.getSystemFlags();
for (Flags.Flag flag : systemFlags) {
if (flag == Flags.Flag.ANSWERED) result.add("ANSWERED");
else if (flag == Flags.Flag.DELETED) result.add("DELETED");
else if (flag == Flags.Flag.DRAFT) result.add("DRAFT");
else if (flag == Flags.Flag.FLAGGED) result.add("FLAGGED");
else if (flag == Flags.Flag.RECENT) result.add("RECENT");
else if (flag == Flags.Flag.SEEN) result.add("SEEN");
}
String[] userFlags = flags.getUserFlags();
Collections.addAll(result, userFlags);
}
return result;
}
private static Map<String, String> extractHeaders(Message message) 
throws MessagingException {
Map<String, String> headers = new HashMap<>();
Enumeration<?> headerEnum = message.getAllHeaderLines();
while (headerEnum.hasMoreElements()) {
String header = (String) headerEnum.nextElement();
int colonIndex = header.indexOf(':');
if (colonIndex > 0) {
String key = header.substring(0, colonIndex).trim();
String value = header.substring(colonIndex + 1).trim();
headers.put(key, value);
}
}
return headers;
}
private static String getMessageId(Message message) throws MessagingException {
String[] messageIds = message.getHeader("Message-ID");
return (messageIds != null && messageIds.length > 0) ? messageIds[0] : null;
}
private static String decodeText(String text) {
if (text == null) return null;
try {
return MimeUtility.decodeText(MimeUtility.unfold(text));
} catch (Exception e) {
return text; // Return original if decoding fails
}
}
// Getters and setters
public String getMessageId() { return messageId; }
public void setMessageId(String messageId) { this.messageId = messageId; }
public String getSubject() { return subject; }
public void setSubject(String subject) { this.subject = subject; }
public String getFrom() { return from; }
public void setFrom(String from) { this.from = from; }
public List<String> getTo() { return to; }
public void setTo(List<String> to) { this.to = to; }
public List<String> getCc() { return cc; }
public void setCc(List<String> cc) { this.cc = cc; }
public List<String> getBcc() { return bcc; }
public void setBcc(List<String> bcc) { this.bcc = bcc; }
public Date getSentDate() { return sentDate; }
public void setSentDate(Date sentDate) { this.sentDate = sentDate; }
public Date getReceivedDate() { return receivedDate; }
public void setReceivedDate(Date receivedDate) { this.receivedDate = receivedDate; }
public String getPlainText() { return plainText; }
public void setPlainText(String plainText) { this.plainText = plainText; }
public String getHtmlText() { return htmlText; }
public void setHtmlText(String htmlText) { this.htmlText = htmlText; }
public List<EmailAttachment> getAttachments() { return attachments; }
public void setAttachments(List<EmailAttachment> attachments) { this.attachments = attachments; }
public Map<String, String> getHeaders() { return headers; }
public void setHeaders(Map<String, String> headers) { this.headers = headers; }
public int getMessageNumber() { return messageNumber; }
public void setMessageNumber(int messageNumber) { this.messageNumber = messageNumber; }
public long getSize() { return size; }
public void setSize(long size) { this.size = size; }
public boolean isSeen() { return seen; }
public void setSeen(boolean seen) { this.seen = seen; }
public boolean isReplied() { return replied; }
public void setReplied(boolean replied) { this.replied = replied; }
public boolean isDeleted() { return deleted; }
public void setDeleted(boolean deleted) { this.deleted = deleted; }
public List<String> getFlags() { return flags; }
public void setFlags(List<String> flags) { this.flags = flags; }
public String getTextContent() {
return plainText != null ? plainText : 
(htmlText != null ? stripHtml(htmlText) : null);
}
private String stripHtml(String html) {
return html.replaceAll("<[^>]+>", "").trim();
}
public boolean hasAttachments() {
return attachments != null && !attachments.isEmpty();
}
@Override
public String toString() {
return String.format(
"EmailMessage{from='%s', subject='%s', date=%s, attachments=%d}",
from, subject, sentDate, attachments.size()
);
}
}
public class EmailAttachment {
private String fileName;
private String contentType;
private byte[] data;
private long size;
// Getters and setters
public String getFileName() { return fileName; }
public void setFileName(String fileName) { this.fileName = fileName; }
public String getContentType() { return contentType; }
public void setContentType(String contentType) { this.contentType = contentType; }
public byte[] getData() { return data; }
public void setData(byte[] data) { this.data = data; }
public long getSize() { return size; }
public void setSize(long size) { this.size = size; }
public String getFileExtension() {
if (fileName == null) return "";
int dotIndex = fileName.lastIndexOf('.');
return dotIndex > 0 ? fileName.substring(dotIndex + 1).toLowerCase() : "";
}
public boolean isImage() {
return contentType != null && contentType.startsWith("image/");
}
public boolean isPdf() {
return "application/pdf".equals(contentType) || 
fileName.toLowerCase().endsWith(".pdf");
}
}

3. Email Reader Interface and Implementation

import javax.mail.*;
import javax.mail.search.SearchTerm;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public interface EmailReader {
// Connection management
void connect() throws EmailException;
void disconnect() throws EmailException;
boolean isConnected();
// Folder operations
List<String> getFolders() throws EmailException;
void openFolder(String folderName) throws EmailException;
void openFolder(String folderName, int mode) throws EmailException;
void closeFolder() throws EmailException;
// Email retrieval
List<EmailMessage> getMessages() throws EmailException;
List<EmailMessage> getMessages(int start, int end) throws EmailException;
EmailMessage getMessage(int messageNumber) throws EmailException;
List<EmailMessage> searchMessages(SearchTerm searchTerm) throws EmailException;
// Email operations
void markAsRead(int messageNumber) throws EmailException;
void markAsUnread(int messageNumber) throws EmailException;
void deleteMessage(int messageNumber) throws EmailException;
void moveMessage(int messageNumber, String targetFolder) throws EmailException;
// Batch operations
int getMessageCount() throws EmailException;
int getUnreadCount() throws EmailException;
// Async operations
CompletableFuture<List<EmailMessage>> getMessagesAsync();
CompletableFuture<Integer> getMessageCountAsync();
}
public class JavaMailEmailReader implements EmailReader {
private final EmailConfig config;
private Session session;
private Store store;
private Folder folder;
private final ExecutorService executor;
public JavaMailEmailReader(EmailConfig config) {
this.config = config;
this.executor = Executors.newCachedThreadPool();
}
@Override
public void connect() throws EmailException {
try {
Properties props = config.toJavaMailProperties();
session = Session.getInstance(props, new Authenticator() {
@Override
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(config.getUsername(), config.getPassword());
}
});
session.setDebug(false); // Set to true for debugging
store = session.getStore(config.getProtocol());
store.connect(config.getHost(), config.getPort(), 
config.getUsername(), config.getPassword());
} catch (Exception e) {
throw new EmailException("Failed to connect to email server", e);
}
}
@Override
public void disconnect() throws EmailException {
try {
if (folder != null && folder.isOpen()) {
folder.close(false);
}
if (store != null && store.isConnected()) {
store.close();
}
} catch (Exception e) {
throw new EmailException("Failed to disconnect from email server", e);
}
}
@Override
public boolean isConnected() {
return store != null && store.isConnected();
}
@Override
public List<String> getFolders() throws EmailException {
checkConnection();
try {
List<String> folderNames = new ArrayList<>();
Folder[] folders = store.getDefaultFolder().list();
for (Folder f : folders) {
folderNames.add(f.getName());
// Recursively get subfolders for IMAP
if (f.getType() == Folder.HOLDS_FOLDERS) {
addSubfolders(f, folderNames, "");
}
}
return folderNames;
} catch (Exception e) {
throw new EmailException("Failed to get folder list", e);
}
}
private void addSubfolders(Folder parent, List<String> folderNames, String prefix) 
throws MessagingException {
Folder[] subfolders = parent.list();
for (Folder subfolder : subfolders) {
String fullName = prefix + "/" + subfolder.getName();
folderNames.add(fullName);
if (subfolder.getType() == Folder.HOLDS_FOLDERS) {
addSubfolders(subfolder, folderNames, fullName);
}
}
}
@Override
public void openFolder(String folderName) throws EmailException {
openFolder(folderName, Folder.READ_ONLY);
}
@Override
public void openFolder(String folderName, int mode) throws EmailException {
checkConnection();
try {
if (folder != null && folder.isOpen()) {
folder.close(false);
}
folder = store.getFolder(folderName);
if (!folder.exists()) {
throw new EmailException("Folder does not exist: " + folderName);
}
folder.open(mode);
} catch (Exception e) {
throw new EmailException("Failed to open folder: " + folderName, e);
}
}
@Override
public void closeFolder() throws EmailException {
try {
if (folder != null && folder.isOpen()) {
folder.close(false);
}
folder = null;
} catch (Exception e) {
throw new EmailException("Failed to close folder", e);
}
}
@Override
public List<EmailMessage> getMessages() throws EmailException {
return getMessages(1, getMessageCount());
}
@Override
public List<EmailMessage> getMessages(int start, int end) throws EmailException {
checkFolderOpen();
try {
int totalMessages = folder.getMessageCount();
if (totalMessages == 0) {
return Collections.emptyList();
}
// Adjust bounds
start = Math.max(1, start);
end = Math.min(totalMessages, end);
List<EmailMessage> messages = new ArrayList<>();
Message[] javaMessages = folder.getMessages(start, end);
// Fetch envelope data first for better performance
folder.fetch(javaMessages, new FetchProfile[] {
FetchProfile.Item.ENVELOPE,
FetchProfile.Item.FLAGS,
FetchProfile.Item.CONTENT_INFO
});
for (Message javaMessage : javaMessages) {
try {
EmailMessage emailMessage = EmailMessage.fromMimeMessage(javaMessage);
messages.add(emailMessage);
} catch (EmailProcessingException e) {
System.err.println("Failed to process message " + 
javaMessage.getMessageNumber() + ": " + e.getMessage());
// Continue with next message
}
}
return messages;
} catch (Exception e) {
throw new EmailException("Failed to get messages", e);
}
}
@Override
public EmailMessage getMessage(int messageNumber) throws EmailException {
checkFolderOpen();
try {
Message javaMessage = folder.getMessage(messageNumber);
if (javaMessage == null) {
throw new EmailException("Message not found: " + messageNumber);
}
// Fetch full content
folder.fetch(new Message[]{javaMessage}, new FetchProfile[] {
FetchProfile.Item.ENVELOPE,
FetchProfile.Item.CONTENT_INFO,
FetchProfile.Item.FLAGS
});
return EmailMessage.fromMimeMessage(javaMessage);
} catch (Exception e) {
throw new EmailException("Failed to get message: " + messageNumber, e);
}
}
@Override
public List<EmailMessage> searchMessages(SearchTerm searchTerm) throws EmailException {
checkFolderOpen();
try {
Message[] javaMessages = folder.search(searchTerm);
List<EmailMessage> messages = new ArrayList<>();
for (Message javaMessage : javaMessages) {
try {
EmailMessage emailMessage = EmailMessage.fromMimeMessage(javaMessage);
messages.add(emailMessage);
} catch (EmailProcessingException e) {
System.err.println("Failed to process search result: " + e.getMessage());
}
}
return messages;
} catch (Exception e) {
throw new EmailException("Failed to search messages", e);
}
}
@Override
public void markAsRead(int messageNumber) throws EmailException {
setMessageFlags(messageNumber, new Flags(Flags.Flag.SEEN), true);
}
@Override
public void markAsUnread(int messageNumber) throws EmailException {
setMessageFlags(messageNumber, new Flags(Flags.Flag.SEEN), false);
}
@Override
public void deleteMessage(int messageNumber) throws EmailException {
setMessageFlags(messageNumber, new Flags(Flags.Flag.DELETED), true);
}
@Override
public void moveMessage(int messageNumber, String targetFolder) throws EmailException {
checkFolderOpen();
try {
Message message = folder.getMessage(messageNumber);
if (message == null) {
throw new EmailException("Message not found: " + messageNumber);
}
Folder target = store.getFolder(targetFolder);
if (!target.exists()) {
throw new EmailException("Target folder does not exist: " + targetFolder);
}
folder.copyMessages(new Message[]{message}, target);
} catch (Exception e) {
throw new EmailException("Failed to move message to: " + targetFolder, e);
}
}
@Override
public int getMessageCount() throws EmailException {
checkFolderOpen();
try {
return folder.getMessageCount();
} catch (Exception e) {
throw new EmailException("Failed to get message count", e);
}
}
@Override
public int getUnreadCount() throws EmailException {
checkFolderOpen();
try {
return folder.getUnreadMessageCount();
} catch (Exception e) {
throw new EmailException("Failed to get unread count", e);
}
}
@Override
public CompletableFuture<List<EmailMessage>> getMessagesAsync() {
return CompletableFuture.supplyAsync(() -> {
try {
return getMessages();
} catch (EmailException e) {
throw new RuntimeException(e);
}
}, executor);
}
@Override
public CompletableFuture<Integer> getMessageCountAsync() {
return CompletableFuture.supplyAsync(() -> {
try {
return getMessageCount();
} catch (EmailException e) {
throw new RuntimeException(e);
}
}, executor);
}
private void setMessageFlags(int messageNumber, Flags flags, boolean set) 
throws EmailException {
checkFolderOpen();
try {
Message message = folder.getMessage(messageNumber);
if (message == null) {
throw new EmailException("Message not found: " + messageNumber);
}
message.setFlags(flags, set);
} catch (Exception e) {
throw new EmailException("Failed to set message flags", e);
}
}
private void checkConnection() throws EmailException {
if (!isConnected()) {
throw new EmailException("Not connected to email server");
}
}
private void checkFolderOpen() throws EmailException {
checkConnection();
if (folder == null || !folder.isOpen()) {
throw new EmailException("No folder open");
}
}
public void setSessionDebug(boolean debug) {
if (session != null) {
session.setDebug(debug);
}
}
@Override
protected void finalize() throws Throwable {
try {
disconnect();
executor.shutdown();
} finally {
super.finalize();
}
}
}

4. Search Utilities

import javax.mail.search.*;
public class EmailSearchBuilder {
public static SearchTerm from(String fromAddress) {
return new FromStringTerm(fromAddress);
}
public static SearchTerm subjectContains(String text) {
return new SubjectTerm(text);
}
public static SearchTerm bodyContains(String text) {
return new BodyTerm(text);
}
public static SearchTerm recipientContains(String address, Message.RecipientType type) {
return new RecipientStringTerm(type, address);
}
public static SearchTerm hasAttachment() {
return new FlagTerm(new Flags(Flags.Flag.FLAGGED), false); // Custom implementation needed
}
public static SearchTerm isUnread() {
return new FlagTerm(new Flags(Flags.Flag.SEEN), false);
}
public static SearchTerm isRead() {
return new FlagTerm(new Flags(Flags.Flag.SEEN), true);
}
public static SearchTerm isFlagged() {
return new FlagTerm(new Flags(Flags.Flag.FLAGGED), true);
}
public static SearchTerm receivedAfter(Date date) {
return new ReceivedDateTerm(ComparisonTerm.GT, date);
}
public static SearchTerm receivedBefore(Date date) {
return new ReceivedDateTerm(ComparisonTerm.LT, date);
}
public static SearchTerm sentAfter(Date date) {
return new SentDateTerm(ComparisonTerm.GT, date);
}
public static SearchTerm sentBefore(Date date) {
return new SentDateTerm(ComparisonTerm.LT, date);
}
public static SearchTerm and(SearchTerm... terms) {
return new AndTerm(terms);
}
public static SearchTerm or(SearchTerm... terms) {
return new OrTerm(terms);
}
public static SearchTerm not(SearchTerm term) {
return new NotTerm(term);
}
// Complex search examples
public static SearchTerm unreadFromImportantSenders() {
return and(
isUnread(),
or(
from("[email protected]"),
from("[email protected]"),
subjectContains("URGENT"),
subjectContains("IMPORTANT")
)
);
}
public static SearchTerm recentPromotions() {
Calendar cal = Calendar.getInstance();
cal.add(Calendar.DAY_OF_MONTH, -7); // Last 7 days
Date weekAgo = cal.getTime();
return and(
receivedAfter(weekAgo),
or(
from("@amazon.com"),
from("@ebay.com"),
subjectContains("sale"),
subjectContains("discount"),
subjectContains("promotion")
)
);
}
}

5. Exception Classes

public class EmailException extends Exception {
public EmailException(String message) {
super(message);
}
public EmailException(String message, Throwable cause) {
super(message, cause);
}
}
public class EmailProcessingException extends EmailException {
public EmailProcessingException(String message) {
super(message);
}
public EmailProcessingException(String message, Throwable cause) {
super(message, cause);
}
}

6. Advanced Email Client with Management Features

import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.File;
import java.io.IOException;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
public class AdvancedEmailClient {
private final EmailReader emailReader;
private final EmailConfig config;
private final ObjectMapper objectMapper;
private final Map<String, List<EmailMessage>> cache;
private final EmailFilterManager filterManager;
public AdvancedEmailClient(EmailConfig config) throws EmailException {
this.config = config;
this.emailReader = new JavaMailEmailReader(config);
this.objectMapper = new ObjectMapper();
this.cache = new ConcurrentHashMap<>();
this.filterManager = new EmailFilterManager();
}
public void connect() throws EmailException {
emailReader.connect();
}
public void disconnect() throws EmailException {
emailReader.disconnect();
cache.clear();
}
public EmailStatistics getStatistics(String folderName) throws EmailException {
emailReader.openFolder(folderName);
int total = emailReader.getMessageCount();
int unread = emailReader.getUnreadCount();
List<EmailMessage> recentMessages = emailReader.getMessages(
Math.max(1, total - 100), total); // Last 100 messages
EmailStatistics stats = new EmailStatistics();
stats.setTotalMessages(total);
stats.setUnreadMessages(unread);
stats.setRecentMessageCount(recentMessages.size());
// Analyze senders
Map<String, Long> senderCounts = recentMessages.stream()
.filter(msg -> msg.getFrom() != null)
.collect(Collectors.groupingBy(EmailMessage::getFrom, Collectors.counting()));
stats.setTopSenders(senderCounts.entrySet().stream()
.sorted(Map.Entry.<String, Long>comparingByValue().reversed())
.limit(10)
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)));
// Analyze subjects for common topics
stats.setCommonTopics(analyzeTopics(recentMessages));
return stats;
}
public List<EmailMessage> getFilteredMessages(String folderName, EmailFilter filter) 
throws EmailException {
emailReader.openFolder(folderName);
List<EmailMessage> messages;
if (cache.containsKey(folderName)) {
messages = cache.get(folderName);
} else {
messages = emailReader.getMessages();
cache.put(folderName, messages);
}
return filterManager.applyFilter(messages, filter);
}
public void exportMessages(String folderName, String outputPath, ExportFormat format) 
throws EmailException, IOException {
emailReader.openFolder(folderName);
List<EmailMessage> messages = emailReader.getMessages();
switch (format) {
case JSON:
exportToJson(messages, outputPath);
break;
case CSV:
exportToCsv(messages, outputPath);
break;
case TEXT:
exportToText(messages, outputPath);
break;
}
}
public void processEmails(String folderName, EmailProcessor processor) throws EmailException {
emailReader.openFolder(folderName);
List<EmailMessage> messages = emailReader.getMessages();
for (EmailMessage message : messages) {
try {
processor.process(message);
} catch (Exception e) {
System.err.println("Failed to process message " + message.getMessageNumber() + 
": " + e.getMessage());
}
}
}
public CompletableFuture<Void> processEmailsAsync(String folderName, EmailProcessor processor) {
return CompletableFuture.runAsync(() -> {
try {
processEmails(folderName, processor);
} catch (EmailException e) {
throw new RuntimeException(e);
}
});
}
private void exportToJson(List<EmailMessage> messages, String outputPath) throws IOException {
List<Map<String, Object>> exportData = messages.stream()
.map(this::messageToMap)
.collect(Collectors.toList());
objectMapper.writerWithDefaultPrettyPrinter()
.writeValue(new File(outputPath), exportData);
}
private void exportToCsv(List<EmailMessage> messages, String outputPath) throws IOException {
// Implementation for CSV export
// Would use a CSV library like OpenCSV
}
private void exportToText(List<EmailMessage> messages, String outputPath) throws IOException {
StringBuilder sb = new StringBuilder();
for (EmailMessage message : messages) {
sb.append("From: ").append(message.getFrom()).append("\n");
sb.append("Subject: ").append(message.getSubject()).append("\n");
sb.append("Date: ").append(message.getSentDate()).append("\n");
sb.append("Body: ").append(message.getTextContent()).append("\n");
sb.append("---\n\n");
}
Files.write(Paths.get(outputPath), sb.toString().getBytes());
}
private Map<String, Object> messageToMap(EmailMessage message) {
Map<String, Object> map = new HashMap<>();
map.put("messageId", message.getMessageId());
map.put("from", message.getFrom());
map.put("subject", message.getSubject());
map.put("sentDate", message.getSentDate());
map.put("receivedDate", message.getReceivedDate());
map.put("hasAttachments", message.hasAttachments());
map.put("isRead", message.isSeen());
map.put("bodyPreview", message.getTextContent() != null ? 
message.getTextContent().substring(0, 
Math.min(200, message.getTextContent().length())) : "");
return map;
}
private Set<String> analyzeTopics(List<EmailMessage> messages) {
// Simple topic analysis based on common words in subjects
Map<String, Integer> wordCounts = new HashMap<>();
for (EmailMessage message : messages) {
if (message.getSubject() != null) {
String[] words = message.getSubject().toLowerCase().split("\\s+");
for (String word : words) {
if (word.length() > 3 && !isCommonWord(word)) {
wordCounts.put(word, wordCounts.getOrDefault(word, 0) + 1);
}
}
}
}
return wordCounts.entrySet().stream()
.sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
.limit(5)
.map(Map.Entry::getKey)
.collect(Collectors.toSet());
}
private boolean isCommonWord(String word) {
Set<String> commonWords = Set.of("the", "and", "for", "with", "this", "that", "your", "have");
return commonWords.contains(word);
}
// Getters
public EmailReader getEmailReader() { return emailReader; }
public EmailFilterManager getFilterManager() { return filterManager; }
}
// Supporting classes
public class EmailStatistics {
private int totalMessages;
private int unreadMessages;
private int recentMessageCount;
private Map<String, Long> topSenders;
private Set<String> commonTopics;
// Getters and setters
public int getTotalMessages() { return totalMessages; }
public void setTotalMessages(int totalMessages) { this.totalMessages = totalMessages; }
public int getUnreadMessages() { return unreadMessages; }
public void setUnreadMessages(int unreadMessages) { this.unreadMessages = unreadMessages; }
public int getRecentMessageCount() { return recentMessageCount; }
public void setRecentMessageCount(int recentMessageCount) { this.recentMessageCount = recentMessageCount; }
public Map<String, Long> getTopSenders() { return topSenders; }
public void setTopSenders(Map<String, Long> topSenders) { this.topSenders = topSenders; }
public Set<String> getCommonTopics() { return commonTopics; }
public void setCommonTopics(Set<String> commonTopics) { this.commonTopics = commonTopics; }
@Override
public String toString() {
return String.format(
"EmailStatistics{total=%d, unread=%d, recent=%d, topSenders=%d, topics=%s}",
totalMessages, unreadMessages, recentMessageCount, 
topSenders.size(), commonTopics
);
}
}
public class EmailFilter {
private String from;
private String subjectContains;
private String bodyContains;
private Boolean hasAttachments;
private Boolean isRead;
private Date receivedAfter;
private Date receivedBefore;
// Getters and setters
public String getFrom() { return from; }
public void setFrom(String from) { this.from = from; }
public String getSubjectContains() { return subjectContains; }
public void setSubjectContains(String subjectContains) { this.subjectContains = subjectContains; }
public String getBodyContains() { return bodyContains; }
public void setBodyContains(String bodyContains) { this.bodyContains = bodyContains; }
public Boolean getHasAttachments() { return hasAttachments; }
public void setHasAttachments(Boolean hasAttachments) { this.hasAttachments = hasAttachments; }
public Boolean getIsRead() { return isRead; }
public void setIsRead(Boolean isRead) { this.isRead = isRead; }
public Date getReceivedAfter() { return receivedAfter; }
public void setReceivedAfter(Date receivedAfter) { this.receivedAfter = receivedAfter; }
public Date getReceivedBefore() { return receivedBefore; }
public void setReceivedBefore(Date receivedBefore) { this.receivedBefore = receivedBefore; }
}
public class EmailFilterManager {
public List<EmailMessage> applyFilter(List<EmailMessage> messages, EmailFilter filter) {
return messages.stream()
.filter(msg -> filter.getFrom() == null || 
(msg.getFrom() != null && msg.getFrom().contains(filter.getFrom())))
.filter(msg -> filter.getSubjectContains() == null || 
(msg.getSubject() != null && msg.getSubject().toLowerCase()
.contains(filter.getSubjectContains().toLowerCase())))
.filter(msg -> filter.getBodyContains() == null || 
(msg.getTextContent() != null && msg.getTextContent().toLowerCase()
.contains(filter.getBodyContains().toLowerCase())))
.filter(msg -> filter.getHasAttachments() == null || 
msg.hasAttachments() == filter.getHasAttachments())
.filter(msg -> filter.getIsRead() == null || 
msg.isSeen() == filter.getIsRead())
.filter(msg -> filter.getReceivedAfter() == null || 
(msg.getReceivedDate() != null && 
!msg.getReceivedDate().before(filter.getReceivedAfter())))
.filter(msg -> filter.getReceivedBefore() == null || 
(msg.getReceivedDate() != null && 
!msg.getReceivedDate().after(filter.getReceivedBefore())))
.collect(Collectors.toList());
}
}
public interface EmailProcessor {
void process(EmailMessage message) throws Exception;
}
public enum ExportFormat {
JSON, CSV, TEXT
}

7. Usage Examples and Demo

import java.util.*;
import java.util.concurrent.CompletableFuture;
public class EmailReaderDemo {
public static void main(String[] args) {
try {
// Configuration for Gmail
EmailConfig config = EmailConfig.gmailImapConfig(
"[email protected]", 
"your-app-password" // Use app password, not regular password
);
AdvancedEmailClient client = new AdvancedEmailClient(config);
client.connect();
System.out.println("Connected to email server");
// Get folder list
List<String> folders = client.getEmailReader().getFolders();
System.out.println("Available folders: " + folders);
// Open INBOX
client.getEmailReader().openFolder("INBOX");
// Get statistics
EmailStatistics stats = client.getStatistics("INBOX");
System.out.println("Email Statistics: " + stats);
// Example 1: Read recent emails
System.out.println("\n--- Recent Emails ---");
List<EmailMessage> recentEmails = client.getEmailReader().getMessages(
Math.max(1, stats.getTotalMessages() - 10), stats.getTotalMessages());
for (EmailMessage email : recentEmails) {
System.out.printf("From: %s\nSubject: %s\nDate: %s\nUnread: %s\n\n",
email.getFrom(), email.getSubject(), email.getSentDate(), !email.isSeen());
}
// Example 2: Search for specific emails
System.out.println("--- Searching for Unread Emails ---");
SearchTerm unreadSearch = EmailSearchBuilder.isUnread();
List<EmailMessage> unreadEmails = client.getEmailReader().searchMessages(unreadSearch);
System.out.println("Found " + unreadEmails.size() + " unread emails");
// Example 3: Filter emails
System.out.println("\n--- Filtered Emails ---");
EmailFilter filter = new EmailFilter();
filter.setHasAttachments(true);
filter.setIsRead(false);
List<EmailMessage> filtered = client.getFilteredMessages("INBOX", filter);
System.out.println("Found " + filtered.size() + " unread emails with attachments");
// Example 4: Process emails with custom processor
System.out.println("\n--- Processing Emails ---");
client.processEmails("INBOX", new EmailProcessor() {
@Override
public void process(EmailMessage message) {
System.out.printf("Processing: %s - %s\n", 
message.getFrom(), message.getSubject());
if (message.hasAttachments()) {
System.out.println("  Has " + message.getAttachments().size() + " attachments");
}
}
});
// Example 5: Async processing
System.out.println("\n--- Async Processing ---");
CompletableFuture<Void> asyncProcess = client.processEmailsAsync("INBOX", message -> {
if (message.getSubject() != null && message.getSubject().contains("newsletter")) {
System.out.println("Newsletter: " + message.getSubject());
// Mark newsletter as read
client.getEmailReader().markAsRead(message.getMessageNumber());
}
});
asyncProcess.thenRun(() -> System.out.println("Async processing completed"));
// Wait for async completion
asyncProcess.get();
// Example 6: Export emails
System.out.println("\n--- Exporting Emails ---");
client.exportMessages("INBOX", "emails_export.json", ExportFormat.JSON);
System.out.println("Emails exported to emails_export.json");
client.disconnect();
System.out.println("Disconnected from email server");
} catch (Exception e) {
System.err.println("Error: " + e.getMessage());
e.printStackTrace();
}
}
}

Key Features

  1. Dual Protocol Support: POP3 and IMAP with SSL/TLS
  2. Comprehensive Email Processing: Full MIME message parsing
  3. Advanced Search: Built-in search utilities with complex query support
  4. Batch Operations: Efficient processing of multiple emails
  5. Async Support: Non-blocking email operations
  6. Export Capabilities: JSON, CSV, and text exports
  7. Filtering System: Flexible email filtering and categorization
  8. Statistics: Email analytics and insights
  9. Attachment Handling: Automatic attachment detection and processing
  10. Error Handling: Comprehensive exception handling and recovery

Security Notes

  • Use app passwords for Gmail instead of regular passwords
  • Enable 2-factor authentication for email accounts
  • Store credentials securely (not in code)
  • Use SSL/TLS connections for security
  • Consider implementing connection pooling for production use

This implementation provides a robust foundation for building email client applications, automation tools, or email processing systems in Java.

Category : JAVA

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper