Criando e Definindo Conteúdos de Emails

Criar Nova Mensagem de Email

Aspose.Email para Java permite que desenvolvedores criem Mensagens MIME (Extensões de Correio da Internet de Múltiplos Propósitos) do zero. A classe principal para esse propósito na API Aspose.Email para Java é a classe MailMessage. Este tópico explica os passos necessários para criar mensagens de email nos formatos de arquivo EML, MSG e MTH usando Aspose.Email para Java.

Para criar uma mensagem de email do zero:

1. Crie uma instância da classe MailMessage.
2. Defina o assunto da mensagem usando o método setSubject() .
3. Defina o corpo da mensagem usando o método setHtmlBody() .
4. Defina o remetente do email usando o método setFrom() .
5. Defina o destinatário no campo TO usando o método getTo().add() .
6. Defina o destinatário no campo CC usando o método getCC().add() .
7. Chame o método Save() para salvar o arquivo da mensagem em disco nos formatos MSG, EML e MHT.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the resource directory.
String dataDir = Utils.getSharedDataDir(CreateNewEmail.class) + "email/";

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

// Set subject of the message
message.setSubject("New message created by Aspose.Email for Java");

// Set Html body
message.setHtmlBody("<b>This line is in bold.</b> <br/> <br/>" + "<font color=blue>This line is in blue color</font>");

// Set sender information
message.setFrom(new MailAddress("[e-mail]", "Sender Name", false));

// Add TO recipients
message.getTo().addMailAddress(new MailAddress("[e-mail]", "Recipient 1", false));
message.getTo().addMailAddress(new MailAddress("[e-mail]", "Recipient 2", false));

//Add CC recipients
message.getCC().addMailAddress(new MailAddress("[e-mail]", "Recipient 3", false));
message.getCC().addMailAddress(new MailAddress("[e-mail]", "Recipient 4", false));

// Save message in EML, MSG and MHTML formats
message.save(dataDir + "Message_out.eml", SaveOptions.getDefaultEml());
message.save(dataDir + "Message_out.msg", SaveOptions.getDefaultMsg());
message.save(dataDir + "Message_out.mhtml", SaveOptions.getDefaultMhtml());

//Save as OFT
try {
	MsgSaveOptions options = SaveOptions.getDefaultMsgUnicode();
	options.setSaveAsTemplate(true);
	message.save(dataDir + "emlToOft_out.oft", options);
} finally {
	if (message != null)
		((IDisposable) message).dispose();
}

Especificando Vários Destinatários

A MailMessage representa uma mensagem de email. Instâncias da classe MailMessage são usadas para construir mensagens de email que são transmitidas para um servidor SMTP usando a classe SmtpClient. Este tópico demonstra como especificar mais de um endereço de email. Os endereços de email podem ser especificados usando a classe MailMessage. Os endereços de email usados na classe MailMessage são:

• Para - Os endereços dos destinatários podem ser especificados no campo ‘Para’. Os destinatários do campo ‘Para’ são o público principal da mensagem. Pode haver mais de um endereço de destinatário.
• Cc - CC significa “cópia carbono”, ou “cópia cortesia”, e permite que você adicione destinatários de email que precisam ver o email, mas que não são necessariamente esperados para agir sobre ele. Gerentes, por exemplo, ou membros da sua equipe que precisam estar cientes de uma conversa. Com Aspose.Email, endereços CC podem ser especificados no seu código. Assim, emails automatizados, ou todos os emails para um endereço específico, podem ser copiados para o pessoal relevante.
• Bcc - Bcc, cópia carbono oculta, permite que você envie um email a um destinatário que está oculto de outros destinatários. Onde um CC aparece nas informações do email que os destinatários principais veem, um Bcc não aparece. É destinado a notificações ocultas.

Para especificar vários endereços de email em uma mensagem de email, siga estas etapas:

1. Crie uma instância da classe MailMessage.
2. Especifique o Remetente e vários endereços Para, Cc e Bcc usando a instância MailMessage.
3. Crie uma instância da classe SmtpClient e envie o email usando o método Send.

O exemplo de código abaixo mostra como vários endereços Para, CC e BCC podem ser especificados.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Declare message as MailMessage instance
// Create an Instance of MailMessage class
MailMessage message = new MailMessage();

// Specify From address
message.setFrom(new MailAddress("[e-mail]"));

//  Specify recipients’ mail addresses
MailAddressCollection toList = new MailAddressCollection();
toList.add("[e-mail]");
toList.add("[e-mail]");
toList.add("[e-mail]");
message.setTo(toList);

// Specify CC addresses
MailAddressCollection ccList = new MailAddressCollection();
ccList.add("[e-mail]");
ccList.add("[e-mail]");
message.setCC(ccList);

// Specify BCC addresses
MailAddressCollection bccList = new MailAddressCollection();
bccList.add("[e-mail]");
bccList.add("[e-mail]");
message.setBcc(bccList);

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

// Specify your mailing host server, Username, Password, 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);

    // Display ‘Message Sent’, only if message sent successfully
    System.out.println("Message sent");
}

catch (Exception ex)
{
    ex.printStackTrace();
}

Mudando endereços de email para um nome amigável

Os exemplos de programação abaixo demonstram como mudar endereços de email para nomes amigáveis em uma mensagem de email. Um nome amigável é um nome que é mais fácil de entender do que o endereço de email, por exemplo, John Smith em vez de [e-mail]. Ao enviar um email, podemos associar um nome amigável a um endereço de email no construtor da classe MailMessage .

Para mudar endereços de email para nomes amigáveis em uma mensagem de email, siga estas etapas:

• Crie uma instância da classe MailMessage e especifique endereços de email nos campos Para e De junto com os nomes amigáveis.
• Especifique os endereços de email Cc e Bcc juntamente com nomes amigáveis chamando o construtor da classe MailMessage na instância MailMessage.
• Crie uma instância da classe SmtpClient e envie o email usando o método Send.

O seguinte trecho de código mostra como exibir Nomes para endereços de email.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
MailMessage message = new MailMessage("Sender Name <[e-mail]>", "Kyle Huang <[e-mail]>");

// A To address with a friendly name can also be specified like this
message.getTo().addMailAddress(new MailAddress("[e-mail]", "Kyle Huang"));

// Specify Cc and Bcc email address along with a friendly name
message.getCC().addMailAddress(new MailAddress("[e-mail]", "Guangzhou Team"));
message.getBcc().addMailAddress(new MailAddress("[e-mail]", "Ammad ulHaq "));

// Create an instance of SmtpClient Class and Specify your mailing host server, Username, Password, Port
SmtpClient client = new SmtpClient();
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)
{
    ex.printStackTrace();
}

Definir Corpo do Email

A classe MailMessage representa uma mensagem de email. Instâncias da classe MailMessage são usadas para construir mensagens de email que são transmitidas para um servidor SMTP para entrega usando a classe SmtpClient. Um corpo de email pode ser especificado usando a classe MailMessage. Um corpo de email pode ser especificado usando o método setHtmlBody na MailMessage.

Além do HtmlBody, Aspose.Email tem outro método relacionado ao corpo do email:

• isBodyHtml: informa ao usuário se o corpo é HTML ou texto simples.

Este tópico mostra como definir o texto do corpo HTML e definir texto alternativo.

Definindo Corpo HTML

HtmlBody é usado para especificar o conteúdo HTML do corpo de uma mensagem. HtmlBody deve ser envolvido entre as tags . O seguinte trecho de código mostra como definir o corpo HTML.

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

// Specify HtmlBody
message.setHtmlBody("<html><body>This is the HTML body</body></html>");

Definindo Texto Alternativo

Use a classe AlternateView para especificar cópias de uma mensagem de email em diferentes formatos. Por exemplo, se você enviar uma mensagem em HTML, pode também querer fornecer uma versão em texto simples caso alguns dos destinatários usem leitores de email que não podem exibir conteúdo HTML. Esta classe possui duas propriedades, LinkedResources e BaseUri, que são usadas para resolver URLs dentro do conteúdo do email.

• LinkedResources é uma coleção de objetos LinkedResources. Quando renderizados, URLs dentro do conteúdo do email são primeiro correspondentes às URLs no Link de Conteúdo de cada objeto LinkedResources na coleção LinkedResources e resolvidos.
• BaseUri é usado pelo leitor de email para resolver URLs relativas dentro do corpo e também para resolver URLs relativas de Link de Conteúdo, na coleção LinkedResources.

O seguinte trecho de código mostra como definir 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);

Especificando Codificação do Corpo do Email

O tipo de conteúdo define o formato de conteúdo do email: o conjunto de caracteres. Por exemplo, alguns conjuntos de caracteres comuns fornecidos em java.nio.Charset são:

• US-ASCII - ASCII de sete bits, também conhecido como ISO646-US, também conhecido como o bloco Latin Básico do conjunto de caracteres Unicode.
• ISO-8859-1 - Alfabeto Latino ISO No. 1, também conhecido como ISO-LATIN-1.
• UTF-8 - Formato de Transformação UCS de oito bits.
• UTF-16BE - Formato de Transformação UCS de dezesseis bits, ordem de bytes big-endian.
• UTF-16LE - Formato de Transformação UCS de dezesseis bits, ordem de bytes little-endian.
• UTF-16 - Formato de Transformação UCS de dezesseis bits, ordem de bytes identificada por uma marca de ordem de bytes opcional.

Aspose.Email usa a propriedade BodyEncoding da classe MailMessage para especificar a codificação do corpo do email. Para codificar o corpo de uma mensagem de email, siga os passos abaixo:

1. Crie uma instância da classe MailMessage.
2. Especifique o remetente, destinatário e corpo HTML do email na instância MailMessage.
3. Especifique o valor da propriedade BodyEncoding.
4. Crie uma instância da classe SmtpClient e envie o email usando o método Send.

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

// Specify From, To, HtmlBody, BodyEncoding field
message.setFrom(new MailAddress("[e-mail]"));
message.getTo().add("[e-mail]");
message.setHtmlBody("<html><body>This is the Html body</body></html>");
message.setBodyEncoding(Charset.forName("US-ASCII"));

// Create an instance of SmtpClient Class and Specify your mailing host server, Username, Password and Port
SmtpClient client = new SmtpClient();
client.setHost("smtp.server.com");
client.setUsername("Username");
client.setPassword("Password");
client.setPort(25);

try
{
    // Client.Send will send this message
    client.send(message);
}
catch (Exception ex)
{
    ex.printStackTrace();
}

Características do MailMessage

A classe MailMessage representa o conteúdo de uma mensagem de email. Instâncias da classe MailMessage são usadas para construir uma mensagem de email que é transmitida para um servidor SMTP para entrega usando a classe SmtpClient. Este artigo mostra como usar os recursos utilitários da classe MailMessage para controlar as seguintes características do email:

• Data e hora - Através do método setDate da classe MailMessage, definimos a data e hora de um email.
• Prioridade da mensagem - A classe MailPriority especifica níveis de prioridade para enviar uma mensagem de email. Pode ser baixa, normal ou alta. A prioridade influencia a velocidade de transmissão e a entrega.
• Sensibilidade da mensagem - A classe MailSensitivity especifica cinco níveis de sensibilidade.
• Notificação de entrega - As notificações de entrega informam aos remetentes que o email que enviaram foi entregue na caixa de entrada do destinatário.

Por padrão, a data é a data atual em que a mensagem foi enviada, e a hora é a hora em que foi enviada, como exibido pelo Microsoft Outlook. No entanto, o tempo real de entrega do email é acrescentado pelo próprio servidor SMTP no cabeçalho do email. Por exemplo, abaixo está um cabeçalho de email comum, onde o campo Data foi configurado usando MailMessage.setDate.

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

// Add by SMTP server in delivery emails
Received: from ip-123.56.99.216.dsl-cust.ca.inter.net ([216.99.56.123]) by Aspose.secureserver.net with MailEnable ESMTP; Thu, 22 Feb 2007 13:58:57 -0700

// Add by SMTP server in delivery emails
Return-Path: <[e-mail]>

// Add by SMTP server in delivery emails
Received: from 195.120.225.20 (HELO mail.oikoscucine.it)
by aspose.com with esmtp (:1CYY+<LA*- *1WK@)
id Q8,/O/-.N83@7-9M
for [e-mail]; Thu, 22 Feb 2007 20:58:51 +0300
From: "XYZ" <[e-mail]>
To: <[e-mail]>
Subject: For ABC

// Date will set the Date field, outlook will show this as
Date: Thu, 22 Feb 2007 20:58:51 +0300
Message-ID: <01c756c4$41b554d0$6c822ecf@dishonestyinsufferably>
MIME-Version: 1.0
Content-Type: multipart/alternative;
boundary="----=_NextPart_000_0006_01C7569A.58DF4CD0"
X-Mailer: Microsoft Office Outlook, Build 11.0.5510
X-MimeOLE: Produced By Microsoft MimeOLE V6.00.2800.1106
Thread-Index: Aca6Q:=ES0M(9-=(<.<1.<Q9@QE6CD==
X-Read: 1

O trecho de código abaixo ilustra como cada um dos recursos discutidos acima pode ser usado.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Create a new message
MailMessage message = new MailMessage();
message.setFrom(new MailAddress("[e-mail]"));
message.getTo().add("[e-mail]");
message.setSubject("Using MailMessage Features");

// Specify message date
message.setDate(new Date());

// Specify message priority
message.setPriority(MailPriority.High);

// Specify message sensitivity
message.setSensitivity(MailSensitivity.Normal);

// Specify options for delivery notifications
message.setDeliveryNotificationOptions(DeliveryNotificationOptions.OnSuccess);

Solicitando um Recebimento de Leitura

Os exemplos de programação abaixo mostram como você pode solicitar um recibo de leitura. A propriedade de enumeração DeliveryNotificationOptions da classe MailMessage descreve as opções de notificação de entrega para um email. Para solicitar um recibo de leitura após enviar um email, siga estas etapas:

1. Crie uma instância da classe MailMessage.
2. Especifique o remetente, destinatário e corpo HTML para o email na instância MailMessage.
3. Especifique as DeliveryNotificationOptions em outras instâncias de MailMessage.
4. Crie uma instância da classe SmtpClient e envie o email usando o método Send.

Recibos de leitura podem nem sempre ser honrados porque:

• Um cliente de email pode não implementar essa funcionalidade.
• O usuário final pode ter essa funcionalidade desativada.
• O usuário final pode optar por não enviar um.

O seguinte trecho de código mostra como solicitar um recibo de leitura.

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

// Specify From, To, HtmlBody, DeliveryNotificationOptions field
message.setFrom(new MailAddress("[e-mail]"));
message.getTo().add("[e-mail]");
message.setHtmlBody("<html><body>This is the Html body</body></html>");
message.setDeliveryNotificationOptions(DeliveryNotificationOptions.OnSuccess);
message.getHeaders().add("Return-Receipt-To", "[e-mail]");
message.getHeaders().add("Disposition-Notification-To", "[e-mail]");

// Create an instance of SmtpClient Class and Specify your mailing host server, Username, Password and Port
SmtpClient client = new SmtpClient();
client.setHost("smtp.server.com");
client.setUsername("Username");
client.setPassword("Password");
client.setPort(25);

try
{
    // Client.Send will send this message
    client.send(message);
}
catch (Exception ex)
{
    ex.printStackTrace();
}

Definir Cabeçalhos de Email

Os cabeçalhos de email representam um padrão da Internet e o RFC define campos de cabeçalho que são incluídos nas mensagens de email da Internet. Um cabeçalho de email pode ser especificado usando a classe MailMessage . Tipos comuns de cabeçalho são definidos na classe HeaderType . É uma classe selada que funciona como uma enumeração normal.

Normalmente, um cabeçalho de email contém estes campos:

• Para: Os endereços dos destinatários podem ser especificados no campo Para. Os destinatários do campo Para são o público principal da mensagem. Pode haver mais de um endereço de destinatário.
• De: Este campo apresenta o endereço de email do remetente da mensagem.
• Cc: Permite que os usuários enviem uma mensagem como uma “Cópia Carbono” ou “Cópia Cortesia”. Ou seja, espera-se que o destinatário não responda ou atue. Normalmente, pessoal supervisor é notificado com CC.
• Bcc: Significa Cópia Carbono Oculta, refere-se à prática de enviar uma mensagem para vários destinatários de tal forma que o que eles recebem não contém a lista completa de destinatários. Destina-se a notificações ocultas.
• ResponderPara: Este campo de cabeçalho é destinado a indicar onde o remetente deseja que as respostas sejam enviadas.
• Assunto: Título, cabeçalho, assunto. Frequentemente usado como indicador de tema para mensagens que respondem ou comentam sobre outras mensagens.
• Data: Este cabeçalho especifica uma data (e hora). Normalmente, esta é a data em que a mensagem foi composta e enviada.
• XMailer: Informações sobre o software cliente do originador. Exemplo: X-Mailer: Aspose.Email. XMailer é usado por clientes de email. Diferentes clientes de email terão diferentes valores de XMailer. O valor de XMailer do MS Outlook é Microsoft Office Outlook, Build 11.0.5510. É ignorado pelo receptor de email ou leitor de email.

Normalmente, um cabeçalho de email se parece com isto:

 Responder-Para: [e-mail]

De: [e-mail]

Para: [e-mail]

Assunto: email de teste

Data: 6 Mar 2006 8:2:2 +0800

X-Mailer: Aspose.Email

Para personalizar um cabeçalho de email, siga estas etapas:

• Crie uma instância da classe MailMessage .
• Especifique Para, De, CC, Bcc, ResponderPara, Assunto, Data e XMailer usando uma instância da classe MailMessage.
• Crie uma instância da classe MimeHeader e especifique o cabeçalho secreto.
• Adicione o cabeçalho secreto à instância MailMessage.

No código abaixo, personalizamos um cabeçalho de email.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Create a new instance of MailMessage class
MailMessage message = new MailMessage();

// Set subject of the message
message.setSubject("New message created by Aspose.Email for Java");

// Set Html body
message.setHtmlBody("<b>This line is in bold.</b> <br/> <br/>" +
		"<font color=blue>This line is in blue color</font>");

// Set sender information
message.setFrom(new MailAddress("[e-mail]", "Sender Name", false));

// Add TO recipients
message.getTo().addItem(new MailAddress("[e-mail]", "Recipient 1", false));

// Message subject
message.setSubject("Customizing Email Headers");

// Specify Date
Calendar calendar = Calendar.getInstance(TimeZone.getTimeZone("GMT"));

Date date = calendar.getTime();
message.setDate(date);

// Specify XMailer
message.setXMailer("Aspose.Email");

// Specify Secret Header
message.getHeaders().add("secret-header", "mystery");

// Save message to disc
message.save(dataDir + "SetEmailHeaders_out.msg", SaveOptions.getDefaultMsg());

O trecho de código acima produz um cabeçalho de email no seguinte formato. Isso pode ser observado abrindo o arquivo MsgHeaders.msg no Microsoft Outlook e depois visualizando suas propriedades.

 Responder-Para: [e-mail]

De: [e-mail]

Para: [e-mail]

CC: [e-mail]

BCC: [e-mail]

Assunto: email de teste

Data: 6 Mar 2006 8:2:2 +0800

X-Mailer: Aspose.Email

cabeçalho-secreto: mistério

Inserir Cabeçalho em Localização Específica

O método Add da Collection de Cabeçalhos insere o cabeçalho no final da coleção. No entanto, pode ser necessário inserir um cabeçalho em uma localização específica. Nesse caso, o método Add não será útil. Para conseguir isso, use o método Insert da Collection de Cabeçalhos. Se a coleção contiver cabeçalhos com o mesmo nome, este cabeçalho será inserido antes de outros cabeçalhos com o mesmo nome. A seguir está a assinatura do método Insert e um código de amostra para uso.

 Assinatura do Método

HeaderCollection.insert(String name, String value)

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Insert Header at Specific Location
MailMessage eml = MailMessage.load(dataDir + "test.eml");
eml.getHeaders().insert("Received", "Value");

Adicionando cabeçalhos personalizados ao email

Os exemplos de programação abaixo demonstram como especificar um cabeçalho personalizado em uma mensagem de email. Um cabeçalho de email pode ser especificado usando a classe MailMessage. Para especificar um cabeçalho personalizado em uma mensagem de email, siga estas etapas:

1. Crie uma instância da classe MailMessage.
2. Especifique os valores para, de e assunto usando a instância MailMessage.
3. Adicione o cabeçalho secreto à instância MailMessage.
4. Crie uma instância da classe SmtpClient e envie o email usando o método Send.

O seguinte trecho de código mostra como adicionar cabeçalhos personalizados ao email.

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

// Specify ReplyTo, from, To, Message subject and secret header field
message.getReplyToList().add("[e-mail]");
message.setFrom(new MailAddress("[e-mail]"));
message.getTo().add("[e-mail]");
message.setSubject("test mail");
message.getHeaders().add("secret-header", "mystery");

// Create an instance of SmtpClient Class and Specify your mailing host server, Username, Password and Port
SmtpClient client = new SmtpClient();
client.setHost("smtp.server.com");
client.setUsername("Username");
client.setPassword("Password");
client.setPort(25);

try
{
    // Client.Send will send this message
    client.send(message);
}
catch (Exception ex)
{
    ex.printStackTrace();
}

Assinar Emails com DKIM

Aspose.Email permite assinar emails com DKIM (DomainKeys Identified Mail). Isso permite que uma organização assuma a responsabilidade por uma mensagem que está em trânsito (sobre DKIM). DKIM adiciona uma assinatura digital aos cabeçalhos da mensagem de email que pode ser validada pelos destinatários. A chave pública do remetente permite que o receptor verifique se a assinatura corresponde ao conteúdo da mensagem. O método dKIMSign da classe MailMessage é utilizado para definir as informações criptográficas e de assinatura para assinar a mensagem. O seguinte trecho de código mostra como assinar emails com DKIM.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
String privateKeyFile = "key2.pem";
RSACryptoServiceProvider rsa = PemReader.getPrivateKey(privateKeyFile);
DKIMSignatureInfo signInfo = new DKIMSignatureInfo("test", "yandex.ru");
signInfo.getHeaders().addItem("From");
signInfo.getHeaders().addItem("Subject");
MailMessage mailMessage = new MailMessage("[e-mail]", "[e-mail]");
mailMessage.setSubject("Signed DKIM message text body");
mailMessage.setBody("This is a text body signed DKIM message");
MailMessage signedMsg = mailMessage.dKIMSign(rsa, signInfo);

try
{
    SmtpClient client = new SmtpClient("smtp.domain.com",25, "username", "password");
    client.send(signedMsg);
}
catch (Exception ex)
{
    ex.printStackTrace();
}
finally
{}

Realizando Mala Direta

Mala direta ajuda você a criar e enviar um lote de mensagens de email similares. O núcleo dos emails é o mesmo, mas o conteúdo pode ser personalizado. Tipicamente, os detalhes de contato de um destinatário (primeiro nome, sobrenome, empresa e assim por diante) são usados para personalizar o email.

Figura: Ilustração de como uma mala direta funciona

Para realizar uma mala direta com Aspose.Email, siga os seguintes passos:

1. Crie uma função com assinatura de nome
2. Crie uma instância da classe MailMessage .
3. Especifique o remetente, destinatário, assunto e corpo.
4. Crie uma assinatura para o final do email.
5. Crie uma instância da classe TemplateRoutine e passe a instância MailMessage .
6. Obtenha a assinatura na instância TemplateRoutine .
7. Crie uma instância da classe DataTable .
8. Adicione as colunas Receipt, FirstName e LastName como fontes de dados na classe DataTable.
9. Crie uma instância da classe DataRow .
10. Especifique o endereço de recebimento, primeiro e últimos nomes no objeto DataRow.
11. Crie uma instância da classe MailMessageCollection .
12. Especifique as instâncias TemplateRoutine e DataTable na instância MailMessageCollection .
13. Crie uma instância da classe SmtpClient e especifique o servidor, porta, nome de usuário e senha.
14. Envie emails usando o método BulkSendAsync da classe SmtpClient .

O código abaixo envia um email para uma pessoa de três outros.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
public static void main(String[] args) {
	//create a new MailMessage instance as a template
	MailMessage template = new MailMessage();

	//add template field to subject
	template.setSubject("Hello, #FirstName#");
	template.setFrom(MailAddress.to_MailAddress("[e-mail]"));

	//add template field to receipt
	template.getTo().addMailAddress(new MailAddress("#Receipt#", true));

	//add template field to html body 
	//use GetSignment as the template routine, which will provide the same signment.
	template.setHtmlBody("Dear #FirstName# #LastName#, <br><br>Thank you for your interest in <STRONG>Aspose.Network</STRONG>.<br><br>Have fun with it.<br><br>#GetSignature()#");

	//create a new TemplateEngine with the template message.
	TemplateEngine engine = new TemplateEngine(template);

	//register the GetSignment as a template routine, for we use it in the template.
	engine.registerRoutine("GetSignature", new TemplateRoutine() {
		public Object invoke(Object[] args) {
			return getSignature(args);
		}
	});
	
	//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.Davolio<[e-mail]>");
	dr.set("FirstName", "Nancy");
	dr.set("LastName", "Davolio");
	dt.getRows().add(dr);
	dr = dt.newRow();
	dr.set("Receipt", "Andrew.Fuller<[e-mail]>");
	dr.set("FirstName", "Andrew");
	dr.set("LastName", "Fuller");
	dt.getRows().add(dr);
	dr = dt.newRow();
	dr.set("Receipt", "Janet.Leverling<[e-mail]>");
	dr.set("FirstName", "Janet");
	dr.set("LastName", "Leverling");
	dt.getRows().add(dr);

	MailMessageCollection messages;
	try
	{
		//create the messages from the template and datasource.
		messages = engine.instantiate(dt);
	}
	catch (MailException ex)
	{
		System.out.println(ex.toString());
	}
}
	
public static Object getSignature(Object[] args) {
    return "John Smith<br>Product Lead<br>Aspose Ltd.<br>".concat(DateTime.getNow().toShortDateString());
}