TheLazy.Dev
Portfolio GitHub

Blog

java |javascript |webdev |programming

Send emails using Java (Javamail API or Simple Java Mail or SuprSend Java SDK)

nikl

Nik L.

Posted on August 2, 2024

Send emails using Java (Javamail API or Simple Java Mail or SuprSend Java SDK)

Method 1: Using JavaMail API for Email Notifications

Overview:

The JavaMail API is a robust, platform-independent, and protocol-independent framework designed to support Java client applications in performing comprehensive email and messaging functionalities. This API offers a generic interface with abstract classes representing various objects created in transactional email systems. It is especially useful for enterprise-level applications where reliability and extensive functionalities are paramount.

Pros:

  1. Well-Structured and Widely Adopted:

    • JavaMail API is renowned for its solid structure and widespread usage, particularly in enterprise environments.

  2. Versatile Functionality:

    • It provides an extensive set of functionalities, including reading, composing, and sending emails.

  3. Programmatic Integration:

    • Simplifies the integration with other programs, making it easier to send confirmations and other messages programmatically.

Cons:

  1. Extended Compilation Time:

    • Developers may face longer code compilation times due to the API's complexity.

  2. Memory Consumption:

    • Using the JavaMail API can lead to significant consumption of Java heap space.

Implementation Steps:

Step 1: Installing JavaMail API

  • Include JAR files (mail.jar and activation.jar) in the CLASSPATH.
  • Configure an SMTP server (e.g., Pepipost) for email transmission.

Step 2: Setting Up the Mail Session

  • Create a session object with host information using javax.mail.Session. 
Properties properties = new Properties(); 
Session session = Session.getDefaultInstance(properties, null);
Enter fullscreen mode Exit fullscreen mode
  • Alternatively: 
Properties properties = new Properties(); 
Session session = Session.getInstance(properties, null);
Enter fullscreen mode Exit fullscreen mode
  • Network authentication: 
Session session = Session.getInstance(properties, new javax.mail.Authenticator() {
  protected PasswordAuthentication getPasswordAuthentication() {
    return new PasswordAuthentication("sender@gmail.com", "password");
  }
});
Enter fullscreen mode Exit fullscreen mode

Step 3: Composing the Email

  • Use the javax.mail.internet.MimeMessage subclass to set the sender, receiver, subject, and message body. 
MimeMessage message = new MimeMessage(session);
message.setFrom(new InternetAddress(from));
message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));
message.setSubject("This is the email subject");
message.setText("This is the email body");
Enter fullscreen mode Exit fullscreen mode

Step 4: Adding Attachments

  • To include attachments, create a Multipart object and add a BodyPart for each attachment. 
Multipart multipart = new MimeMultipart();

BodyPart messageBodyPart = new MimeBodyPart();
messageBodyPart.setText("This is the email body");
multipart.addBodyPart(messageBodyPart);

messageBodyPart = new MimeBodyPart();
DataSource source = new FileDataSource("path/to/attachment.txt");
messageBodyPart.setDataHandler(new DataHandler(source));
messageBodyPart.setFileName("attachment.txt");
multipart.addBodyPart(messageBodyPart);

message.setContent(multipart);
Enter fullscreen mode Exit fullscreen mode

Step 5: Sending the Email

  • Use the javax.mail.Transport class to send the email. 
Transport.send(message);
Enter fullscreen mode Exit fullscreen mode

Complete Code Example: 

import java.util.Properties;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;

public class SendMail {
    public static void main(String[] args) {
      String to = "receiver@gmail.com";
      String from = "sender@gmail.com";
      String host = "smtp.gmail.com";

      Properties properties = System.getProperties();
      properties.put("mail.smtp.host", host);
      properties.put("mail.smtp.port", "465");
      properties.put("mail.smtp.ssl.enable", "true");
      properties.put("mail.smtp.auth", "true");

      Session session = Session.getInstance(properties, new javax.mail.Authenticator(){
        protected PasswordAuthentication getPasswordAuthentication() {
          return new PasswordAuthentication("sender@gmail.com", "password");
        }
      });

      try {
        MimeMessage message = new MimeMessage(session);
        message.setFrom(new InternetAddress(from));
        message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));
        message.setSubject("Your email subject goes here");

        Multipart multipart = new MimeMultipart();
        BodyPart messageBodyPart = new MimeBodyPart();
        messageBodyPart.setText("You have a new message");
        multipart.addBodyPart(messageBodyPart);

        messageBodyPart = new MimeBodyPart();
        DataSource source = new FileDataSource("path/to/attachment.txt");
        messageBodyPart.setDataHandler(new DataHandler(source));
        messageBodyPart.setFileName("attachment.txt");
        multipart.addBodyPart(messageBodyPart);

        message.setContent(multipart);

        Transport.send(message);
      } catch (MessagingException mex) {
        mex.printStackTrace();
      }
   }
}
Enter fullscreen mode Exit fullscreen mode

Method 2: Using Simple Java Mail for Email Notifications

Overview:

Simple Java Mail is a user-friendly mailing library designed to simplify the process of sending SMTP emails in Java. It serves as a wrapper around the JavaMail API, streamlining the email sending process by reducing the complexity of the underlying API.

Pros:

  1. Robust and Lightweight:

    • Simple Java Mail is robust while maintaining a lightweight footprint of 134kB.

  2. RFC Compliance:

    • It complies with all relevant RFCs, ensuring compatibility with various email clients.

  3. Authenticated SOCKS Proxy Support:

    • Supports sending emails through an authenticated SOCKS proxy.

  4. Advanced Features:

    • Offers support for HTML content, images, and attachments, and allows sending emails to multiple recipients simultaneously.

Cons:

  1. Limited Community Support:
    • The community support for Simple Java Mail is smaller compared to JavaMail API.

Implementation Steps:

Step 1: Creating an Email Object with HTML and Attachments 

Email email = EmailBuilder.startingBlank()
    .from("From", "from@example.com")
    .to("1st Receiver", "rec1@example.com")
    .to("2nd Receiver", "rec2@example.com")
    .withSubject("Enhanced Email with HTML and Attachments")
    .withHTMLText("<html><body><h1>Hello!</h1><p>This is an enhanced email with HTML content.</p></body></html>")
    .withAttachment("path/to/attachment.txt")
    .buildEmail();
Enter fullscreen mode Exit fullscreen mode

Step 2: Creating a Mailer Object using MailerBuilder 

Mailer mailer = MailerBuilder
    .withSMTPServer("smtp.mailtrap.io", 2525, "username", "password")
    .withTransportStrategy(TransportStrategy.SMTPS)
    .buildMailer();
Enter fullscreen mode Exit fullscreen mode

Step 3: Sending the Enhanced Email 

mailer.sendMail(email);
Enter fullscreen mode Exit fullscreen mode

Complete Code Example: 

import org.simplejavamail.api.email.Email;
import org.simplejavamail.email.EmailBuilder;
import org.simplejavamail.mailer.Mailer;
import org.simplejavamail.mailer.MailerBuilder;
import org.simplejavamail.api.mailer.config.TransportStrategy;

public class SendEnhancedMail {
    public static void main(String[] args) {
        Email email = EmailBuilder.startingBlank()
            .from("From", "from@example.com")
            .to("1st Receiver", "case1@example.com")
            .to("2nd Receiver", "case2@example.com")
            .withSubject("Enhanced Email with HTML and Attachments")
            .withHTMLText("<html><body><h1>Hello!</h1><p>This is an enhanced email with HTML content.</p></body></html>")
            .withAttachment("path/to/attachment.txt")
            .buildEmail();

        Mailer mailer = MailerBuilder
            .withSMTPServer("smtp.mailtrap.io", 2525, "username", "password")
            .withTransportStrategy(TransportStrategy.SMTPS)
            .buildMailer();

        mailer.sendMail(email);
    }
}
Enter fullscreen mode Exit fullscreen mode

Method 3: Using SuprSend for Multichannel Notifications with JAVA SDKs

Overview:

SuprSend offers a comprehensive third-party multichannel notification infrastructure that supports sending notifications across various channels like email, SMS, and push notifications through a unified API. By leveraging SuprSend, developers can manage complex notification workflows seamlessly.

Key Features & Benefits:

  1. Extensive Integration Options:

    • Integrates seamlessly with over 50 Communication Service Providers (CSPs) and supports multiple channels including Mixpanel, Segment, Twilio, Mailchimp, Slack, Teams, SNS, Vonage, Whatsapp, and more.

  2. No Tech Dependency:

    • Manages the entire notification lifecycle without heavy reliance on the engineering team. Integrate the JAVA SDK once, and the product team can handle the rest.

  3. Intelligent Routing:

    • Implements intelligent cross-channel flows across providers without requiring technical dependencies.

  4. In-App SDK:

    • Provides a developer-ready in-app layer for both web and mobile applications.

  5. Granular Template Management:

    • Features an intuitive drag & drop editor for designing templates, offering superior control over content.

  6. Powerful Workspace:

    • Manages multiple projects with distinct integrations, workflows, and templates within each workspace.

  7. Unified Analytics:

    • Provides a unified view of cross-channel analytics, enabling data-driven decision-making.

  8. Smart Automation:

    • Automates synchronization, refreshing, and notification triggers to streamline operations.

  9. Scalability:

    • Automates scalability, ensuring a hassle-free experience.

Cons:

  1. Cost Considerations:
    • Managing multiple notification channels may incur costs.
  2. *Monthly Notification Limit:*
    • Though SuprSend provides 10k notifications free every month, which resets every month, you can also buy credits.

Limits:**

  • There may be restrictions on the number of notifications per month.

Implementation Steps:

Step 1: Integrating the JAVA SDK

  1. Install the SuprSend JAVA SDK:
    • Add the SDK to your JAVA project via Maven or Gradle.

Step 2: Configuring the API Key and Workspace Secret

  1. Set Up Configuration:
    • Obtain the API key and workspace secret from your SuprSend account and configure them in your JAVA project.

Step 3: Creating and Sending Notifications

  1. Send Notifications via JAVA SDK:
    • Use the SDK to send notifications, specifying the required channel (email, SMS, push, etc.) and the content. 
import com.suprsend.Notification;
import com.suprsend.NotificationBuilder;
import com.suprsend.SuprSendClient;

public class SendNotification {
    public static void main(String[] args) {
        // Initialize the SuprSendClient with API key and Workspace Secret
        SuprSendClient client = new SuprSendClient("your_api_key", "your_workspace_secret");

        // Build the notification
        Notification notification = NotificationBuilder.startingBlank()
            .withRecipientEmail("recipient@example.com")
            .withRecipientSMS("recipient_phone_number")
            .withSubject("Notification Subject")
            .withHTMLBody("<html><body><h1>Hello!</h1><p>This is a multichannel notification.</p></body></html>")
            .build();

        // Send the notification
        client.sendNotification(notification);
    }
}
Enter fullscreen mode Exit fullscreen mode

Complete Code Example with JAVA SDK: 

import com.suprsend.Notification;
import com.suprsend.NotificationBuilder;
import com.suprsend.SuprSendClient;

public class SuprSendExample {
    public static void main(String[] args) {
        // Initialize the SuprSendClient with API key and Workspace Secret
        SuprSendClient client = new SuprSendClient("your_api_key", "your_workspace_secret");

        // Create the notification
        Notification notification = NotificationBuilder.startingBlank()
            .withRecipientEmail("receiver@example.com")
            .withSubject("Subject of the Notification")
            .withHTMLBody("<html><body><h1>Hello!</h1><p>This is a notification from SuprSend.</p></body></html>")
            .withAttachment("path/to/attachment.txt")
            .build();

        // Send the notification
        client.sendNotification(notification);
    }
}
Enter fullscreen mode Exit fullscreen mode

These methods offer a comprehensive guide to sending email notifications using Java, with varying levels of complexity and integration capabilities to suit different needs and scenarios.

You may want to check out other SuprSend SDKs too. Consider giving us a star after usage. It's free and open.

GitHub logo suprsend / suprsend-go

SuprSend SDK for go

suprsend-go

SuprSend Go SDK

Installation

go get github.com/suprsend/suprsend-go
Enter fullscreen mode Exit fullscreen mode

Usage

Initialize the SuprSend SDK

import (
    "log"

    suprsend "github.com/suprsend/suprsend-go"
)

func main() {
    opts := []suprsend.ClientOption{
        // suprsend.WithDebug(true),
    }
    suprClient, err := suprsend.NewClient("__api_key__", "__api_secret__", opts...)
    if err != nil {
        log.Println(err)
    }
}
Enter fullscreen mode Exit fullscreen mode

Trigger Workflow

package main
import (
    "log"

    suprsend "github.com/suprsend/suprsend-go"
)

func main() {
    // Instantiate Client
    suprClient, err := suprsend.NewClient("__api_key__", "__api_secret__")
    if err != nil {
        log.Println(err)
        return
    }
    // Create WorkflowTriggerRequest body
    wfReqBody := map[string]interface{}{
        "workflow": "workflow-slug",
        "recipients": []map[string]interface{}{
            {
                "distinct_id": "0f988f74-6982-41c5-8752-facb6911fb08",
                // if $channels is present, communication will be tried on mentioned channels only (for this request).
                // "$channels": []string{"email"},
…
Enter fullscreen mode Exit fullscreen mode
View on GitHub

GitHub logo suprsend / suprsend-py-sdk

SuprSend SDK for python3

suprsend-py-sdk

This package can be included in a python3 project to easily integrate with SuprSend platform.

Installation

suprsend-py-sdk is available on PyPI. You can install using pip.

pip install suprsend-py-sdk
Enter fullscreen mode Exit fullscreen mode

This SDK depends on a system package called libmagic. You can install it as follows:

# On debian based systems
sudo apt install libmagic

# If you are using macOS
brew install libmagic
Enter fullscreen mode Exit fullscreen mode

Usage

Initialize the SuprSend SDK

from suprsend import Suprsend
# Initialize SDK
supr_client = Suprsend("workspace_key", "workspace_secret")
Enter fullscreen mode Exit fullscreen mode

Following example shows a sample request for triggering a workflow. It triggers a pre-created workflow purchase-made to a recipient with id: distinct_id, email: user@example.com & androidpush(fcm-token): __android_push_fcm_token__

from suprsend import WorkflowTriggerRequest
# Prepare Workflow body
wf = WorkflowTriggerRequest(
  body={
    "workflow": "purchase-made"
    "recipients": [
        {
          "distinct_id": "0f988f74-6982-41c5-8752-facb6911fb08",
          # if $channels is present, communication will be tried on mentioned
…
Enter fullscreen mode Exit fullscreen mode
View on GitHub

GitHub logo suprsend / suprsend-node-sdk

Official SuprSend SDK for Node.js

suprsend-node-sdk

This package can be included in a node project to easily integrate with SuprSend platform.

Installation

npm install @suprsend/node-sdk@latest
Enter fullscreen mode Exit fullscreen mode

Initialization

const { Suprsend } = require("@suprsend/node-sdk");

const supr_client = new Suprsend("workspace_key", "workspace_secret");
Enter fullscreen mode Exit fullscreen mode

Trigger workflow from API

It is a unified API to trigger workflow and doesn't require user creation before hand. If you are using our frontend SDK's to configure notifications and passing events and user properties from third-party data platforms like Segment, then event-based trigger would be a better choice.

const { Suprsend, WorkflowTriggerRequest } = require("@suprsend/node-sdk");
const supr_client = new Suprsend("workspace_key", "workspace_secret");

// workflow payload
const body = {
  workflow: "_workflow_slug_",
  actor: {
    distinct_id: "0fxxx8f74-xxxx-41c5-8752-xxxcb6911fb08",
    name: "actor_1",
  },
  recipients: [
    {
      distinct_id: "0gxxx9f14-xxxx-23c5-1902-xxxcb6912ab09",
      $email: ["abc@example.com"
…
Enter fullscreen mode Exit fullscreen mode
View on GitHub

GitHub logo suprsend / suprsend-react-inbox

SuprSend SDK for integrating inbox functionality in React applications

@suprsend/react-inbox

Integrating SuprSend Inbox channel in React websites can be done in two ways:

  • SuprSendInbox component which comes with UI and customizing props.
  • SuprSendProvider headless component and hooks, incase you want to totally take control of UI. (example: Full page notifications).

Detailed documentation can be found here: https://docs.suprsend.com/docs/inbox-react

Installation

You can install SuprSend inbox SDK using npm/yarn

npm install @suprsend/react-inbox
Enter fullscreen mode Exit fullscreen mode

SuprSendInbox Integration

After installing, Import the component in your code and use it as given below. Replace the variables with actual values.

import SuprSendInbox from '@suprsend/react-inbox'
import 'react-toastify/dist/ReactToastify.css' // needed for toast notifications, can be ignored if hideToast=true

// add to your react component;
<SuprSendInbox
  workspaceKey='<workspace_key>'
  subscriberId='<subscriber_id>'
  distinctId='<distinct_id>'
/>
Enter fullscreen mode Exit fullscreen mode 
interface ISuprSendInbox {
  workspaceKey: string
  distinctId: string | null
  subscriberId: string | null
  tenantId?: string
  stores?: IStore[]
  pageSize?: number
  pagination?: boolean
…
Enter fullscreen mode Exit fullscreen mode
View on GitHub
💖 💪 🙅 🚩
nikl
Nik L.

Posted on August 2, 2024

Join Our Newsletter. No Spam, Only the good stuff.

Sign up to receive the latest update from our blog.

Related

The Evolution of State Management in JavaScript
javascript The Evolution of State Management in JavaScript

November 28, 2024

Objetos em JavaScript
javascript Objetos em JavaScript

November 16, 2024

Understanding WeakRefs and FinalizationRegistry in JavaScript
javascript Understanding WeakRefs and FinalizationRegistry in JavaScript

November 21, 2024

The Evolution of JavaScript
javascript The Evolution of JavaScript

November 14, 2024

The Bad Sides of JavaScript
javascript The Bad Sides of JavaScript

November 12, 2024