Envio e encaminhamento de mensagens - Enviar mensagens de Outlook usando programa Java

O SmtpClient classe permite que aplicações enviem e‑mail usando o Simple Mail Transfer Protocol (SMTP).

  • O SmtpClient classe é a única entrada principal que os desenvolvedores utilizam para enviar mensagens de e‑mail.
  • O SmtpClient classe também fornece outros métodos comuns de entrega de e‑mail, incluindo gravação de mensagens de e‑mail no sistema de arquivos, filas de mensagens etc.
  • O SmtpClient classe suporta totalmente esses dois modelos de programação:
  • O SmtpClient classe também suporta envio de mensagens como TNEF

Para enviar a mensagem de e‑mail e bloquear enquanto espera que o e‑mail seja transmitido ao servidor SMTP, use um dos métodos Send síncronos. Para permitir que a thread principal do seu programa continue executando enquanto o e‑mail é transmitido, use o beginSend método.

Enviando E‑mails Síncronamente

Uma mensagem de e‑mail pode ser enviada de forma síncrona usando o SmtpClient classe send método. Ele envia a mensagem de e‑mail especificada através de um servidor SMTP para entrega. O remetente, destinatários, assunto e corpo da mensagem são especificados usando objetos String. Para enviar uma mensagem de e‑mail de forma síncrona, siga os passos abaixo:

  1. Crie uma instância de MailMessage classe e definir suas propriedades.
  2. Crie uma instância de SmtpClient classe e especificar o Host, porta, nome de usuário e senha.
  3. Enviar a Mensagem usando o SmtpClient classe send método e passar o MailMessage instância.

O trecho de código Java a seguir mostra como enviar e‑mails do Outlook de forma síncrona.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java

// Declare msg as MailMessage instance
MailMessage msg = new MailMessage();

// Create an instance of SmtpClient class
SmtpClient client = new SmtpClient();

// Specify your mailing host server, Username, Password, Port # and Security option
client.setHost("mail.server.com");
client.setUsername("username");
client.setPassword("password");
client.setPort(587);
client.setSecurityOptions(SecurityOptions.SSLExplicit);

try {
    // Client.Send will send this message
    client.send(msg);
    System.out.println("Message sent");
} catch (Exception ex) {
    System.err.println(ex);
}

Enviando E‑mails Assincronamente

Às vezes, você pode querer enviar e‑mail de forma assíncrona. Por exemplo, se estiver enviando muitos e‑mails através da sua aplicação, a abordagem síncrona pode não funcionar. Nesse cenário, você pode usar beginSend. O beginSend método do SmtpClient classe envia uma mensagem de e‑mail para um servidor SMTP para entrega. Este método não bloqueia a thread chamadora e permite que o chamador passe um objeto ao método que será invocado quando a operação for concluída. Para enviar uma mensagem de e‑mail do Outlook de forma assíncrona em Java, siga estes passos:

  1. Crie uma instância de MailMessage classe e usar suas diferentes propriedades.
  2. Crie uma instância de SmtpClient classe e especificar o host, porta, nome de usuário e senha.
  3. Crie uma instância definida pelo usuário que será passada ao método e invocada quando a operação assíncrona for concluída.
  4. Enviar a mensagem usando beginSend método de SmtpClient classe e passar o MailMessage instância e instância definida pelo usuário nela, juntamente com uma função de retorno de chamada a ser executada quando a operação for concluída.

Para receber uma notificação quando o e‑mail for enviado ou a operação for cancelada, a função de retorno de chamada passada para o beginSend método é chamado. Após chamar o SmtpClient classe beginSend método não é necessário esperar que a mensagem de e‑mail seja enviada completamente. Podemos chamar outro método beginSend ao mesmo tempo. Quando um e‑mail foi enviado usando o beginSend método, o trecho de código imprime uma mensagem ("Mensagem enviada"). O programa Java ou trecho de código a seguir mostra como enviar e‑mails de forma assíncrona.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java

public static void run() {
    sendMail();
}

static SmtpClient getSmtpClient() {
    SmtpClient client = new SmtpClient();
    client.setHost("mail.server.com");
    // Specify your mail Username, Password, Port # and security option
    client.setUsername("username");
    client.setPassword("password");
    client.setPort(587);
    client.setSecurityOptions(SecurityOptions.SSLExplicit);
    return client;
}

static void sendMail() {
    try {

        // Declare msg as MailMessage instance
        MailMessage msg = new MailMessage("sender@gmail.com", "receiver@gmail.com", "Test subject", "Test body");
        SmtpClient client = getSmtpClient();
        Object state = new Object();
        IAsyncResult ar = client.beginSend(msg, callback, state);
        // If the user canceled the send, and mail hasn't been sent yet,
        client.cancelAsyncOperation(ar);

        msg.dispose();
        System.out.println("Goodbye.");
    } catch (Exception ex) {
        System.err.println(ex);
    }
}

static AsyncCallback callback = new AsyncCallback() {
    public void invoke(IAsyncResult ar) {
        IAsyncResultExt task = null;
        if (ar instanceof IAsyncResult)
            task = (IAsyncResultExt) ar;

        if (task != null && task.isCanceled()) {
            System.out.println("Send canceled.");
        }

        if (task != null && task.getErrorInfo() != null) {
            System.out.println(task.getErrorInfo());
        } else {
            System.out.println("Message Sent.");
        }
    }
};

Enviando mensagens armazenadas do disco

Arquivos EML (Arquivos de e‑mail do Outlook Express) contêm um cabeçalho de e‑mail, corpo da mensagem e quaisquer anexos. O Aspose.Email permite que desenvolvedores trabalhem com arquivos EML de diferentes maneiras. Este artigo mostra como carregar arquivos EML do disco e enviá‑los como e‑mails via SMTP. Você pode carregar arquivos .eml do disco ou de um fluxo para o MailMessage classe e envie a mensagem de e‑mail usando o SmtpClient classe. O MailMessage classe que é a principal para criar novas mensagens de e‑mail, carregar arquivos de mensagens de e‑mail do disco ou fluxo e salvar as mensagens. O seguinte trecho de código Java mostra como enviar mensagens armazenadas do disco.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java

// Load an EML file in MailMessage class
MailMessage message = MailMessage.load(dataDir + "test.eml");

// Send this message using SmtpClient
SmtpClient client = new SmtpClient("host", "username", "password");

try {
    client.send(message);
} catch (Exception ex) {
    System.out.println(ex.getMessage());
}

Enviando e‑mail em texto simples

Os exemplos de programação abaixo mostram como enviar um e‑mail em texto simples. O Corpo propriedade, uma propriedade da MailMessage classe, que é usada para especificar o conteúdo em texto simples do corpo da mensagem. Para enviar um e‑mail em texto simples, siga estes passos:

  • Crie uma instância do MailMessage classe.
  • Especifique os endereços de e‑mail do remetente e do destinatário no MailMessage instância.
  • Especifique o Corpo conteúdo, usado para a mensagem em texto simples.
  • Crie uma instância do SmtpClient classe e envie o e‑mail.

O trecho de código a seguir mostra como enviar um e‑mail em texto simples.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java

// Create an instance of the MailMessage class
MailMessage message = new MailMessage();

// Set From field, To field and Plain text body
message.setFrom(MailAddress.to_MailAddress("sender@sender.com"));
message.getTo().add("receiver@receiver.com");
message.setBody("This is Plain Text Body");

// Create an instance of the SmtpClient class
SmtpClient client = new SmtpClient();

// And Specify your mailing host server, Username, Password and Port
client.setHost("smtp.server.com");
client.setUsername("Username");
client.setPassword("Password");
client.setPort(25);

try {
    // Client.Send will send this message
    client.send(message);
    System.out.println("Message sent");
} catch (Exception ex) {
    System.err.println(ex);
}

Enviando e‑mail com corpo HTML

Os exemplos de programação abaixo mostram como você pode enviar uma mensagem simples de e‑mail HTML. O HtmlBody, uma propriedade da MailMessage classe, que é usada para especificar o conteúdo HTML do corpo da mensagem. Para enviar um e‑mail HTML simples, siga estes passos:

  • Crie uma instância do MailMessage classe.
  • Especifique o endereço de e‑mail do remetente e do destinatário no MailMessage instância.
  • Especifique o HtmlBody conteúdo.
  • Crie uma instância do SmtpClient classe e envie o e‑mail usando o send método.

Para fins deste artigo, o conteúdo HTML do e‑mail é rudimentar: Este é o corpo HTML A maioria dos e‑mails HTML será mais complexa. O trecho de programa Java a seguir mostra como enviar um e‑mail com corpo HTML.

public static void run() {
    // Declare msg as MailMessage instance
    MailMessage msg = new MailMessage();

    // Use MailMessage properties like specify sender, recipient, message and HtmlBody
    msg.setFrom(MailAddress.to_MailAddress("newcustomeronnet@gmail.com"));
    msg.setTo(MailAddressCollection.to_MailAddressCollection("asposetest123@gmail.com"));
    msg.setSubject("Test subject");
    msg.setHtmlBody("<html><body>This is the HTML body</body></html>");
    SmtpClient client = getSmtpClient();
    try {
        // Client will send this message
        client.send(msg);
        System.out.println("Message sent");
    } catch (Exception ex) {
        System.err.println(ex);
    }

    System.out.println("Email sent with HTML body.");
}

private static SmtpClient getSmtpClient() {
    SmtpClient client = new SmtpClient("smtp.gmail.com", 587, "your.email@gmail.com", "your.password");
    client.setSecurityOptions(SecurityOptions.Auto);
    return client;
}

Enviando e‑mail com texto alternativo da mensagem

Os exemplos de programação abaixo mostram como enviar uma mensagem simples de e‑mail HTML com conteúdo alternativo. Use o AlternateView classe para especificar cópias de uma mensagem de e‑mail em diferentes formatos. Por exemplo, se você enviar uma mensagem em HTML, pode também desejar fornecer uma versão em texto simples para destinatários que usam leitores de e‑mail que não podem exibir conteúdo HTML. Ou, se estiver enviando um boletim, pode querer fornecer uma cópia em texto simples para os destinatários que optaram por receber a versão em texto simples. Para enviar um e‑mail com texto alternativo, siga estes passos:

  1. Crie uma instância do MailMessage classe.
  2. Especifique os endereços de e‑mail do remetente e do destinatário no MailMessage instância.
  3. Crie uma instância do AlternateView classe.

Isso cria uma visualização alternativa para uma mensagem de e‑mail usando o conteúdo especificado na string.

  1. Adicione a instância do AlternateView classe para o MailMessage objeto.
  2. Crie uma instância do SmtpClient classe e envie o e‑mail usando o send método.

O trecho de código a seguir mostra como enviar um e‑mail com texto alternativo.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java

// Declare message as MailMessage instance
MailMessage message = new MailMessage();

// Creates AlternateView to view an email message using the content specified in the //String
AlternateView alternate = AlternateView.createAlternateViewFromString("Alternate Text");

// Adding alternate text
message.getAlternateViews().addItem(alternate);

Enviando e‑mails em massa

Enviar e‑mails em massa significa enviar um lote de e‑mails em uma única mensagem. Podemos enviar um lote de e‑mails usando o SmtpClient classe send sobrecarga de método que aceita um MailMessageCollection classe:

  1. Crie uma instância de SmtpClient classe.
  2. Especifique o SmtpClient propriedades da classe.
  3. Crie uma instância do MailMessage classe.
  4. Especifique o remetente, destinatário, assunto e mensagem na instância do MailMessage classe.
  5. Repita os dois passos acima novamente, se quiser enviar e‑mail para outra pessoa.
  6. Crie uma instância de MailMessageCollection classe.
  7. Adicione uma instância de MailMessage classe no objeto do MailMessageCollection classe.
  8. Agora envie seu e‑mail usando o SmtpClient classe send método passando a instância de MailMessageCollection classe nele.

O trecho de código a seguir mostra como enviar e‑mails em massa.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java

// Create SmtpClient as client and specify server, port, user name and password
SmtpClient client = new SmtpClient("mail.server.com", 25, "Username", "Password");

// Create instances of MailMessage class and Specify To, From, Subject and Message
MailMessage message1 = new MailMessage("msg1@from.com", "msg1@to.com", "Subject1", "message1, how are you?");
MailMessage message2 = new MailMessage("msg1@from.com", "msg2@to.com", "Subject2", "message2, how are you?");
MailMessage message3 = new MailMessage("msg1@from.com", "msg3@to.com", "Subject3", "message3, how are you?");

// Create an instance of MailMessageCollection class
MailMessageCollection manyMsg = new MailMessageCollection();
manyMsg.addItem(message1);
manyMsg.addItem(message2);
manyMsg.addItem(message3);

// Use client.BulkSend function to complete the bulk send task
try {
    // Send Message using BulkSend method
    client.send(manyMsg);
    System.out.println("Message sent");
} catch (Exception ex) {
    System.err.println(ex);
}

Obter informações sobre mensagens enviadas em massa

Quando você envia mensagens em massa, pode obter informações sobre o número de mensagens enviadas com sucesso e a lista dessas mensagens. O SucceededSending evento é usado para esse fim.

O exemplo de código abaixo mostra como obter informações sobre o número de mensagens enviadas com sucesso:

try (SmtpClient client = new SmtpClient(host, SecurityOptions.Auto)) {
    final AtomicInteger messageCount = new AtomicInteger(0);

    client.setSucceededSending(new EventHandler<MailMessageEventArgs>() {
        public void invoke(Object sender, MailMessageEventArgs eventArgs) {
            System.out.println("The message " + eventArgs.getMessage().getSubject() + " was successfully sent.");
            messageCount.incrementAndGet();
        }
    });

    client.send(messages);

    System.out.println(messageCount + " messages were successfully sent.");
}

Enviando e‑mails com MultiConnection

SmtpClient fornece um UseMultiConnection propriedade que pode ser usada para criar múltiplas conexões para operações intensas. Você também pode definir o número de conexões a ser usado durante o modo multiconexão usando SmtpClient.ConnectionsQuantity. O trecho de código a seguir demonstra o uso do modo multiconexão para enviar várias mensagens.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java

SmtpClient smtpClient = new SmtpClient();
smtpClient.setHost("<HOST>");
smtpClient.setUsername("<USERNAME>");
smtpClient.setPassword("<PASSWORD>");
smtpClient.setPort(587);
smtpClient.setSupportedEncryption(EncryptionProtocols.Tls);
smtpClient.setSecurityOptions(SecurityOptions.SSLExplicit);

List<MailMessage> messages = new ArrayList<MailMessage>();
for (int i = 0; i < 20; i++) {
    MailMessage message = new MailMessage("<EMAIL ADDRESS>", "<EMAIL ADDRESS>", "Test Message - " + UUID.randomUUID().toString(),
            "SMTP Send Messages with MultiConnection");
    messages.add(message);
}

smtpClient.setConnectionsQuantity(5);
smtpClient.setUseMultiConnection(MultiConnectionMode.Enable);
smtpClient.send(messages);

Enviando uma Mensagem como TNEF

E‑mails TNEF têm formatação especial que pode ser perdida se enviados usando a API padrão. Aspose.Email fornece a capacidade de enviar e‑mails como TNEF, preservando assim o formato. O SmtpClient classe UseTnef propriedade pode ser definida para enviar o e‑mail como TNEF. O trecho de código a seguir mostra como enviar uma mensagem como TNEF.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java

String emlFileName = dataDir + "Message.eml"; // A TNEF Email

// Load from eml
MailMessage eml1 = MailMessage.load(emlFileName, new EmlLoadOptions());
eml1.setFrom(MailAddress.to_MailAddress("somename@gmail.com"));
eml1.getTo().clear();
eml1.getTo().addItem(new MailAddress("first.last@test.com"));
eml1.setSubject("With PreserveTnef flag during loading");
eml1.setDate(new Date());
SmtpClient client = new SmtpClient("smtp.gmail.com", 587, "somename", "password");
client.setSecurityOptions(SecurityOptions.Auto);
client.setUseTnef(true); // Use this flag to send as TNEF
client.send(eml1);

Enviando Solicitações de Reunião

Microsoft Outlook oferece funções de calendário assim como gerenciamento de e‑mail. Quando um usuário abre um e‑mail com um convite para um evento, o Outlook solicita que ele aceite ou rejeite o convite. Aspose.Email permite que desenvolvedores adicionem funções de calendário aos seus e‑mails.

Enviando Solicitações via E‑mail

Para enviar solicitações de reunião via e‑mail, siga estes passos:

  • Crie uma instância do MailMessage classe.
  • Especifique endereços de remetente e destinatário usando uma instância do MailMessage classe.
  • Inicialize uma instância da Appointment classe e passar seus valores.
  • Especifique resumo e descrição no Calendar instância.
  • Adicionar o Calendar) para o MailMessage instância e passar o Appointment instância.

|Solicitação de reunião iCalendar enviada por e‑mail| | :- | |todo:image_alt_text| O trecho de código a seguir mostra como enviar solicitações via e‑mail.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java

// Create an instance of the MailMessage class
MailMessage msg = new MailMessage();

// Set the sender, recipient, who will receive the meeting request. Basically, the recipient is the same as the meeting attendees
msg.setFrom(MailAddress.to_MailAddress("newcustomeronnet@gmail.com"));
msg.setTo(MailAddressCollection.to_MailAddressCollection("person1@domain.com, person2@domain.com, person3@domain.com, asposetest123@gmail.com"));

// Create Appointment instance
Calendar cal = Calendar.getInstance();
cal.set(2015, Calendar.JULY, 17, 13, 0, 0);
Date startDate = cal.getTime();
cal.set(2015, Calendar.JULY, 17, 14, 0, 0);
Date endDate = cal.getTime();
Appointment app = new Appointment("Room 112", startDate, endDate, msg.getFrom(), msg.getTo());
app.setSummary("Release Meetting");
app.setDescription("Discuss for the next release");

// Add appointment to the message and Create an instance of SmtpClient class
msg.addAlternateView(app.requestApointment());
SmtpClient client = getSmtpClient();

try {
    // Client.Send will send this message
    client.send(msg);
    System.out.println("Message sent");
} catch (Exception ex) {
    System.err.println(ex);
}

Suporte iCalendar para IBM Lotus Notes

O recurso de calendário do Aspose.Email baseia‑se no padrão iCalendar, um padrão para troca de dados de calendário (RFC 2445 ou Referência de Sintaxe RFC2445). Portanto, ele suporta não só Microsoft Outlook, mas também IBM Lotus Notes. Para enviar uma solicitação de reunião no Lotus Notes, siga os mesmos passos mencionados acima.

Encaminhar um E‑mail usando Cliente SMTP

Encaminhando E‑mail com cliente SMTP

Encaminhar um e‑mail é uma prática comum na comunicação digital diária. Um e‑mail recebido pode ser encaminhado para destinatários específicos sem compartilhar com os remetentes originais. Aspose.Email API SmtpClient fornece a capacidade de encaminhar um e‑mail para destinatários específicos. Seu Encaminhar método pode ser usado para encaminhar um e‑mail recebido ou salvo para destinatários desejados como mostrado neste artigo. O trecho de código a seguir mostra como encaminhar um e‑mail usando SMTP Client.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java

// Create an instance of SmtpClient class
SmtpClient client = new SmtpClient();

// Specify your mailing host server, Username, Password, Port and SecurityOptions
client.setHost("mail.server.com");
client.setUsername("username");
client.setPassword("password");
client.setPort(587);
client.setSecurityOptions(SecurityOptions.SSLExplicit);
MailMessage message = MailMessage.load(dataDir + "Message.eml");
client.forward("Recipient1@domain.com", "Recipient2@domain.com", message);

Encaminhando E‑mail sem usar MailMessage

A API também suporta encaminhamento de mensagens EML sem primeiro carregá‑las em MailMessage. Isso é útil em casos onde há recursos limitados em termos de memória do sistema.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java

String host = "mail.server.com";
String username = "username";
String password = "password";
int smtpPort = 587;
String sender = "Sender@domain.com";
MailAddressCollection recipients = new MailAddressCollection();
recipients.add("recepient1@domain.com, recepient2@domain.com");

try (SmtpClient client = new SmtpClient(host, smtpPort, username, password, SecurityOptions.Auto)) {
    String fileName = "test.eml";
    try (FileInputStream fs = new FileInputStream(new File(dataDir + fileName))) {
        client.forward(sender, recipients, fs);
    }
}

Realizando Mail Merge

Mail merges ajudam a criar e enviar um lote de mensagens de e‑mail semelhantes. O núcleo dos e‑mails é o mesmo, mas o conteúdo pode ser personalizado. Normalmente, os detalhes de contato do destinatário (primeiro nome, sobrenome, empresa etc.) são usados para personalizar o e‑mail.

|Ilustração de como funciona uma mesclagem de e‑mail:| | :- | |todo:image_alt_text| Aspose.Email permite que desenvolvedores configurem mesclagens de e‑mail que incluam dados de uma variedade de fontes de dados.

Para executar um mail merge com Aspose.Email, siga os passos a seguir:

  1. Crie uma função com a assinatura de nome
  2. Crie uma instância do MailMessage classe.
  3. Especifique o remetente, destinatário, assunto e corpo.
  4. Crie uma assinatura para o final do e‑mail.
  5. Crie uma instância do TemplateEngine classe e passe-a para o MailMessage instância.
  6. Obtenha assinatura no TemplateEngine instância.
  7. Crie uma instância do DataTable classe.
  8. Adicione as colunas Receipt, FirstName e LastName como fontes de dados no DataTable classe.
  9. Crie uma instância do DataRow classe.
  10. Especifique o endereço de recebimento, nome e sobrenome no DataRow objeto.
  11. Crie uma instância do MailMessageCollection classe
  12. Especifique o TemplateEngine  e DataTable instâncias no MailMessageCollection instância.
  13. Crie uma instância do SmtpClient classe e especificar o servidor, porta, nome de usuário e senha.
  14. Enviar e‑mails usando o SmtpClient classe send método.

No exemplo abaixo, #FirstName# indica um DataTable coluna, cujo valor é definido pelo usuário. O trecho de código a seguir mostra como realizar a Mesclagem de E‑mail.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
public static void run() {
    // The path to the File directory.
    String dstEmail = dataDir + "EmbeddedImage.msg";

    // Create a new MailMessage instance
    MailMessage msg = new MailMessage();

    // Add subject and from address
    msg.setSubject("Hello, #FirstName#");
    msg.setFrom(MailAddress.to_MailAddress("sender@sender.com"));

    // Add email address to send email also Add mesage field to HTML body
    msg.getTo().add("your.email@gmail.com");
    String htmlBody = "Your message here/r/n" + "Thank you for your interest in <STRONG>Aspose.Email</STRONG>.";

    // Use GetSignment as the template routine, which will provide the same signature
    htmlBody += "<br><br>Have fun with it.<br><br>#GetSignature()#";

    msg.setHtmlBody(htmlBody);

    // Create a new TemplateEngine with the MSG message, Register GetSignature routine. It will be used in MSG.
    TemplateEngine engine = new TemplateEngine(msg);
    engine.registerRoutine("GetSignature", new TemplateRoutine() {
        public Object invoke(Object[] args) {
            return getSignature(args);
        }
    });

    // Create an instance of DataTable and Fill a DataTable as data source
    DataTable dt = new DataTable();
    dt.getColumns().add("Receipt");
    dt.getColumns().add("FirstName");
    dt.getColumns().add("LastName");

    DataRow dr;
    dr = dt.newRow();
    dr.set("Receipt", "Nancy&lt;Nancy@somedomain.com&gt;");
    dr.set("FirstName", "Nancy");
    dr.set("LastName", "Doe");
    dt.getRows().add(dr);
    dr = dt.newRow();
    dr.set("Receipt", "Andrew&lt;Andrew@somedomain.com&gt;");
    dr.set("FirstName", "Andrew");
    dr.set("LastName", "Doe");
    dt.getRows().add(dr);
    dr = dt.newRow();
    dr.set("Receipt", "Janet&lt;Janet@somedomain.com&gt;");
    dr.set("FirstName", "Janet");
    dr.set("LastName", "Doe");
    dt.getRows().add(dr);

    MailMessageCollection messages;
    try {
        // Create messages from the message and datasource.
        messages = engine.instantiate(dt);

        // Create an instance of SmtpClient and specify server, port, username and password
        SmtpClient client = new SmtpClient("smtp.gmail.com", 587, "your.email@gmail.com", "your.password");
        client.setSecurityOptions(SecurityOptions.Auto);

        // Send messages in bulk
        client.send(messages);
    } catch (MailException ex) {
        System.err.println(ex);
    }

    catch (SmtpException ex) {
        System.err.println(ex);
    }

    System.out.println("Message sent after performing mail merge.");
}

// Template routine to provide signature
static Object getSignature(Object[] args) {
    return "Aspose.Email Team<br>Aspose Ltd.<br>" + new Date().toString();
}

Realizando Mesclagem de E‑mail Linha a Linha

O usuário pode mesclar linhas de dados individuais também para obter um completo e preparado MailMessage objeto. O TemplateEngine.merge método pode ser usado para realizar uma mesclagem de e‑mail linha a linha.

// Create message from the data in current row.
MailMessage message = engine.merge(currentRow);
Conectando ao Servidor SMTP Recursos Utilitários - Cliente SMTP