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);

• Alternatively:

Properties properties = new Properties(); 
Session session = Session.getInstance(properties, null);

• Network authentication:

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

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");

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);

Step 5: Sending the Email

• Use the javax.mail.Transport class to send the email.

Transport.send(message);

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();
      }
   }
}

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("<h1 id="Hello">Hello!</h1><p>This is an enhanced email with HTML content.</p>")
    .withAttachment("path/to/attachment.txt")
    .buildEmail();

Step 2: Creating a Mailer Object using MailerBuilder

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

Step 3: Sending the Enhanced Email

mailer.sendMail(email);

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("<h1 id="Hello">Hello!</h1><p>This is an enhanced email with HTML content.</p>")
            .withAttachment("path/to/attachment.txt")
            .buildEmail();

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

        mailer.sendMail(email);
    }
}

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("<h1 id="Hello">Hello!</h1><p>This is a multichannel notification.</p>")
            .build();

        // Send the notification
        client.sendNotification(notification);
    }
}

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("<h1 id="Hello">Hello!</h1><p>This is a notification from SuprSend.</p>")
            .withAttachment("path/to/attachment.txt")
            .build();

        // Send the notification
        client.sendNotification(notification);
    }
}

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.

suprsend / suprsend-go

SuprSend SDK for go

suprsend-go

SuprSend Go SDK

Installation

go get github.com/suprsend/suprsend-go

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)
    }
}

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 workflow body
    wfBody := map[string]interface{}{
        "name":                  "Workflow Name",
        "template":              "template slug",
        "notification_category": "category",
        // "delay":                 "15m", // Chek duration format in documentation
        "users": []map[string]interface{}{
            {
                "distinct_id": "0f988f74-6982-41c5-8752-facb6911fb08",
                

…

View on GitHub

---

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.

We're working towards creating SDK in other languages as well.

SuprSend SDKs available in following languages

• python3 >= 3.7 (suprsend-py-sdk)
• node (suprsend-node-sdk)
• java (suprsend-java-sdk)

Installation

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

pip install suprsend-py-sdk

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

<span class="pl-c"># On debian based systems</span>
sudo apt install libmagic

<span class="pl-c"># If you are using macOS</span>
brew install libmagic

Usage

Initialize the SuprSend SDK

from suprsend import Suprsend
# Initialize SDK
supr_client = Suprsend("workspace_key", "workspace_secret")

Following example shows a sample request for triggering a workflow. It triggers a notification to a user with id: distinct_id, email: user@example.com & androidpush(fcm-token): __android_push_fcm_token__ using template purchase-made and notification_category system

from suprsend import Workflow

…

View on GitHub

---

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

Initialization

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

const supr_client = new Suprsend("workspace_key", "workspace_secret");

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"

…

View on GitHub

---

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

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>"></suprsendinbox>

interface ISuprSendInbox {
  workspaceKey: string
  distinctId: string | null
  subscriberId: string | null
  tenantId?: string
  stores?: IStore[]
  pageSize?: number
  pagination?: boolean

…

View on GitHub

The above is the detailed content of Send emails using Java (Javamail API or Simple Java Mail or SuprSend Java SDK). For more information, please follow other related articles on the PHP Chinese website!