JavaMail API - Panduan Cepat
JavaMail API menyediakan kerangka kerja yang tidak bergantung platform dan protokol untuk membangun aplikasi email dan perpesanan. JavaMail API menyediakan sekumpulan kelas abstrak yang mendefinisikan objek yang terdiri dari sistem email. Ini adalah paket opsional (ekstensi standar) untuk membaca, menulis, dan mengirim pesan elektronik.
JavaMail menyediakan elemen yang digunakan untuk membangun antarmuka ke sistem perpesanan, termasuk komponen sistem dan antarmuka. Meskipun spesifikasi ini tidak menentukan implementasi spesifik apa pun, JavaMail menyertakan beberapa kelas yang menerapkan standar perpesanan Internet RFC822 dan MIME. Kelas-kelas ini dikirimkan sebagai bagian dari paket kelas JavaMail.
Berikut adalah beberapa protokol yang didukung di JavaMail API:
SMTP: Akronim untuk Simple Mail Transfer Protocol. Ini menyediakan mekanisme untuk mengirim email.
POP: Akronim untuk Post Office Protocol. POP adalah mekanisme yang digunakan kebanyakan orang di Internet untuk mendapatkan email. Ini mendefinisikan dukungan untuk satu kotak surat untuk setiap pengguna. RFC 1939 mendefinisikan protokol ini.
IMAP: Akronim untuk Internet Message Access Protocol. Ini adalah protokol lanjutan untuk menerima pesan. Ini memberikan dukungan untuk beberapa kotak surat untuk setiap pengguna, selain itu, kotak surat dapat digunakan bersama oleh beberapa pengguna. Ini didefinisikan dalam RFC 2060.
MIME: Akronim untuk Multipurpose Internet Mail Extensions. . Ini bukan protokol transfer surat. Sebaliknya, ini mendefinisikan konten apa yang ditransfer: format pesan, lampiran, dan sebagainya. Ada banyak dokumen berbeda yang berlaku di sini: RFC 822, RFC 2045, RFC 2046, dan RFC 2047. Sebagai pengguna JavaMail API, Anda biasanya tidak perlu khawatir tentang format ini. Namun, format ini memang ada dan digunakan oleh program Anda.
NNTP and Others: Ada banyak protokol yang disediakan oleh penyedia pihak ketiga. Beberapa di antaranya adalah Network News Transfer Protocol (NNTP), Secure Multipurpose Internet Mail Extensions (S / MIME) dll.
Rinciannya akan dibahas di bab-bab selanjutnya.
Arsitektur
Seperti yang dikatakan di atas, aplikasi java menggunakan JavaMail API untuk menulis, mengirim, dan menerima email. Gambar berikut menggambarkan arsitektur JavaMail:
Mekanisme abstrak JavaMail API mirip dengan J2EE API lainnya, seperti JDBC, JNDI, dan JMS. Seperti yang terlihat pada diagram arsitektur di atas, JavaMail API dibagi menjadi dua bagian utama:
Bagian aplikasi-independen: Antarmuka pemrograman aplikasi (API) digunakan oleh komponen aplikasi untuk mengirim dan menerima pesan email, terlepas dari penyedia atau protokol yang digunakan.
Bagian yang bergantung pada layanan: Antarmuka penyedia layanan (SPI) menggunakan bahasa khusus protokol, seperti SMTP, POP, IMAP, dan Network News Transfer Protocol (NNTP). Ini digunakan untuk menghubungkan penyedia layanan email ke platform J2EE.
Untuk mengirim email menggunakan Aplikasi Java Anda cukup sederhana tetapi untuk memulainya Anda harus punya JavaMail API dan Java Activation Framework (JAF) dipasang di mesin Anda.
Anda akan membutuhkan JavaBeans Activation Framework (JAF)ekstensi yang menyediakan paket javax.activation hanya jika Anda tidak menggunakan Java SE 6 atau yang lebih baru.
Anda dapat mengunduh JavaMail versi terbaru (Versi 1.5.0) dari situs web standar Java.
Anda dapat mengunduh versi terbaru JAF (Versi 1.1.1) dari situs web standar Java.
Unduh dan unzip file ini, di direktori tingkat atas yang baru dibuat Anda akan menemukan sejumlah file jar untuk kedua aplikasi tersebut. Anda perlu menambahkanmail.jar dan activation.jar file di CLASSPATH Anda.
Server SMTP
Untuk mengirim email, Anda harus memiliki server SMTP yang bertanggung jawab untuk mengirim email. Anda dapat menggunakan salah satu teknik berikut untuk mendapatkan server SMTP:
Instal dan gunakan server SMTP seperti server Postfix (untuk Ubuntu), server Apache James (Java Apache Mail Enterprise Server), dll. (atau)
Menggunakan server SMTP yang disediakan oleh penyedia host untuk misalnya: SMTP bebas memberikan oleh JangoSMTP situs relay.jangosmtp.net (atau)
Gunakan Server SMTP yang disediakan oleh perusahaan misalnya gmail, yahoo, dll.
Contoh di bab selanjutnya, kami telah menggunakan server JangoSMTP gratis untuk mengirim email. Anda dapat membuat akun dengan mengunjungi situs ini dan mengkonfigurasi alamat email Anda.
JavaMail API terdiri dari beberapa antarmuka dan kelas yang digunakan untuk mengirim, membaca, dan menghapus pesan email. Meskipun ada banyak paket dalam API JavaMail, akan mencakup dua paket utama yang digunakan di Jawa Mail API sering: javax.mail dan javax.mail.internet paket. Paket-paket ini berisi semua kelas inti JavaMail. Mereka:
| Kelas | Deskripsi |
|---|---|
| javax.mail.Session | Kelas kunci API. Objek multithread mewakili pabrik koneksi. |
| javax.mail.Message | Kelas abstrak yang memodelkan pesan email. Subclass menyediakan implementasi yang sebenarnya. |
| javax.mail.Address | Kelas abstrak yang memodelkan alamat (dari dan ke alamat) dalam pesan. Subclass menyediakan implementasi spesifik. |
| javax.mail.Authenticator | Kelas abstrak yang digunakan untuk melindungi sumber daya email di server email. |
| javax.mail.Transport | Kelas abstrak yang memodelkan mekanisme transportasi pesan untuk mengirim pesan email. |
| javax.mail.Store | Kelas abstrak yang memodelkan penyimpanan pesan dan protokol aksesnya, untuk menyimpan dan mengambil pesan. Toko dibagi menjadi beberapa Folder. |
| javax.mail.Folder | Kelas abstrak yang mewakili folder pesan email. Ini dapat berisi subfolder. |
| javax.mail.internet.MimeMessage | Pesan adalah kelas abstrak, karenanya harus bekerja dengan subkelas; dalam banyak kasus, Anda akan menggunakan MimeMessage. MimeMessage adalah pesan email yang memahami jenis dan header MIME. |
| javax.mail.internet.InternetAddress | Kelas ini mewakili alamat email Internet menggunakan sintaks RFC822. Sintaks alamat khas adalah dari bentuk [email protected] atau Nama Pribadi <[email protected]> . |
Berikut adalah contoh mengirim email sederhana. Di sini kami telah menggunakan server JangoSMTP yang melaluinya email dikirim ke alamat email tujuan kami. Pengaturan dijelaskan di bab Pengaturan Lingkungan .
Untuk mengirim email sederhana, langkah-langkah yang diikuti adalah:
Dapatkan Sesi
Buat objek MimeMessage default dan setel Dari, Kepada, Subjek di pesan.
Tetapkan pesan yang sebenarnya sebagai:
message.setText("your text goes here");Kirim pesan menggunakan objek Transport.
Buat Kelas Java
Buat file kelas java SendEmail, yang isinya adalah sebagai berikut:
package com.tutorialspoint;
import java.util.Properties;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
public class SendEmail {
public static void main(String[] args) {
// Recipient's email ID needs to be mentioned.
String to = "[email protected]";
// Sender's email ID needs to be mentioned
String from = "[email protected]";
final String username = "manishaspatil";//change accordingly
final String password = "******";//change accordingly
// Assuming you are sending email through relay.jangosmtp.net
String host = "relay.jangosmtp.net";
Properties props = new Properties();
props.put("mail.smtp.auth", "true");
props.put("mail.smtp.starttls.enable", "true");
props.put("mail.smtp.host", host);
props.put("mail.smtp.port", "25");
// Get the Session object.
Session session = Session.getInstance(props,
new javax.mail.Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(username, password);
}
});
try {
// Create a default MimeMessage object.
Message message = new MimeMessage(session);
// Set From: header field of the header.
message.setFrom(new InternetAddress(from));
// Set To: header field of the header.
message.setRecipients(Message.RecipientType.TO,
InternetAddress.parse(to));
// Set Subject: header field
message.setSubject("Testing Subject");
// Now set the actual message
message.setText("Hello, this is sample for to check send " +
"email using JavaMailAPI ");
// Send message
Transport.send(message);
System.out.println("Sent message successfully....");
} catch (MessagingException e) {
throw new RuntimeException(e);
}
}
}Karena kami menggunakan server SMTP yang disediakan oleh penyedia host JangoSMTP, kami perlu mengautentikasi nama pengguna dan kata sandi. Kelas javax.mail.PasswordAuthentication digunakan untuk mengotentikasi kata sandi.
Kompilasi dan Jalankan
Sekarang kelas kita sudah siap, mari kita kompilasi kelas di atas. Saya telah menyimpan kelas SendEmail.java ke direktori:/home/manisha/JavaMailAPIExercise. Kita membutuhkan jars javax.mail.jar dan activation.jar di classpath. Jalankan perintah di bawah ini untuk mengkompilasi kelas (kedua jars ditempatkan di direktori / home / manisha /) dari command prompt:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmail.javaSekarang kelas telah dikompilasi, jalankan perintah di bawah ini untuk menjalankan:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmailVerifikasi Output
Anda akan melihat pesan berikut di konsol perintah:
Sent message successfully....Saat saya mengirim email ke alamat gmail saya melalui JangoSMTP, email berikut akan diterima di kotak masuk akun gmail saya:
Berikut adalah contoh untuk mengirim email dengan lampiran dari mesin Anda. File di mesin lokal adalahfile.txtditempatkan di / home / manisha / . Di sini kami telah menggunakan server JangoSMTP yang melaluinya email dikirim ke alamat email tujuan kami. Pengaturan dijelaskan di bab Pengaturan Lingkungan .
Untuk mengirim email dengan gambar sebaris, langkah-langkah yang diikuti adalah:
Dapatkan Sesi
Buat objek MimeMessage default dan setel Dari, Kepada, Subjek di pesan.
Atur pesan yang sebenarnya seperti di bawah ini:
messageBodyPart.setText("This is message body");Buat objek MimeMultipart. Tambahkan messageBodyPart di atas dengan pesan aktual yang ditetapkan di dalamnya, ke objek multi bagian ini.
Selanjutnya tambahkan lampiran dengan membuat Datahandler sebagai berikut:
messageBodyPart = new MimeBodyPart(); String filename = "/home/manisha/file.txt"; DataSource source = new FileDataSource(filename); messageBodyPart.setDataHandler(new DataHandler(source)); messageBodyPart.setFileName(filename); multipart.addBodyPart(messageBodyPart);Selanjutnya atur multi bagian dalam pesan sebagai berikut:
message.setContent(multipart);Kirim pesan menggunakan objek Transport.
Buat Kelas Java
Buat file kelas java SendAttachmentInEmail, yang isinya adalah sebagai berikut:
package com.tutorialspoint;
import java.util.Properties;
import javax.activation.DataHandler;
import javax.activation.DataSource;
import javax.activation.FileDataSource;
import javax.mail.BodyPart;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Multipart;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMultipart;
public class SendAttachmentInEmail {
public static void main(String[] args) {
// Recipient's email ID needs to be mentioned.
String to = "[email protected]";
// Sender's email ID needs to be mentioned
String from = "[email protected]";
final String username = "manishaspatil";//change accordingly
final String password = "******";//change accordingly
// Assuming you are sending email through relay.jangosmtp.net
String host = "relay.jangosmtp.net";
Properties props = new Properties();
props.put("mail.smtp.auth", "true");
props.put("mail.smtp.starttls.enable", "true");
props.put("mail.smtp.host", host);
props.put("mail.smtp.port", "25");
// Get the Session object.
Session session = Session.getInstance(props,
new javax.mail.Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(username, password);
}
});
try {
// Create a default MimeMessage object.
Message message = new MimeMessage(session);
// Set From: header field of the header.
message.setFrom(new InternetAddress(from));
// Set To: header field of the header.
message.setRecipients(Message.RecipientType.TO,
InternetAddress.parse(to));
// Set Subject: header field
message.setSubject("Testing Subject");
// Create the message part
BodyPart messageBodyPart = new MimeBodyPart();
// Now set the actual message
messageBodyPart.setText("This is message body");
// Create a multipar message
Multipart multipart = new MimeMultipart();
// Set text message part
multipart.addBodyPart(messageBodyPart);
// Part two is attachment
messageBodyPart = new MimeBodyPart();
String filename = "/home/manisha/file.txt";
DataSource source = new FileDataSource(filename);
messageBodyPart.setDataHandler(new DataHandler(source));
messageBodyPart.setFileName(filename);
multipart.addBodyPart(messageBodyPart);
// Send the complete message parts
message.setContent(multipart);
// Send message
Transport.send(message);
System.out.println("Sent message successfully....");
} catch (MessagingException e) {
throw new RuntimeException(e);
}
}
}Karena kami menggunakan server SMTP yang disediakan oleh penyedia host JangoSMTP, kami perlu mengautentikasi nama pengguna dan kata sandi. Kelas javax.mail.PasswordAuthentication digunakan untuk mengotentikasi kata sandi.
Kompilasi dan Jalankan
Sekarang kelas kita sudah siap, mari kita kompilasi kelas di atas. Saya telah menyimpan kelas SendAttachmentInEmail.java ke direktori:/home/manisha/JavaMailAPIExercise. Kita membutuhkan jars javax.mail.jar dan activation.jar di classpath. Jalankan perintah di bawah ini untuk mengkompilasi kelas (kedua jars ditempatkan di direktori / home / manisha /) dari command prompt:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendAttachmentInEmail.javaSekarang kelas telah dikompilasi, jalankan perintah di bawah ini untuk menjalankan:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendAttachmentInEmailVerifikasi Output
Anda akan melihat pesan berikut di konsol perintah:
Sent message successfully....Saat saya mengirim email ke alamat gmail saya melalui JangoSMTP, email berikut akan diterima di kotak masuk akun gmail saya:
Berikut adalah contoh untuk mengirim email HTML dari mesin Anda. Di sini kami telah menggunakan server JangoSMTP yang melaluinya email dikirim ke alamat email tujuan kami. Pengaturan dijelaskan di bab Pengaturan Lingkungan .
Contoh ini sangat mirip dengan pengiriman email sederhana, kecuali bahwa, di sini kita menggunakan metode setContent () untuk menyetel konten yang argumen keduanya adalah "teks / html" untuk menentukan bahwa konten HTML disertakan dalam pesan. Dengan menggunakan contoh ini, Anda dapat mengirim konten HTML sebesar yang Anda suka.
Untuk mengirim email dengan konten HTML, langkah-langkah yang diikuti adalah:
Dapatkan Sesi
Buat objek MimeMessage default dan setel Dari, Kepada, Subjek di pesan.
Setel pesan aktual menggunakan metode setContent () seperti di bawah ini:
message.setContent("<h1>This is actual message embedded in HTML tags</h1>", "text/html");Kirim pesan menggunakan objek Transport.
Buat Kelas Java
Buat file kelas java SendHTMLEmail, yang isinya adalah sebagai berikut:
package com.tutorialspoint;
import java.util.Properties;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
public class SendHTMLEmail {
public static void main(String[] args) {
// Recipient's email ID needs to be mentioned.
String to = "[email protected]";
// Sender's email ID needs to be mentioned
String from = "[email protected]";
final String username = "manishaspatil";//change accordingly
final String password = "******";//change accordingly
// Assuming you are sending email through relay.jangosmtp.net
String host = "relay.jangosmtp.net";
Properties props = new Properties();
props.put("mail.smtp.auth", "true");
props.put("mail.smtp.starttls.enable", "true");
props.put("mail.smtp.host", host);
props.put("mail.smtp.port", "25");
// Get the Session object.
Session session = Session.getInstance(props,
new javax.mail.Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(username, password);
}
});
try {
// Create a default MimeMessage object.
Message message = new MimeMessage(session);
// Set From: header field of the header.
message.setFrom(new InternetAddress(from));
// Set To: header field of the header.
message.setRecipients(Message.RecipientType.TO,
InternetAddress.parse(to));
// Set Subject: header field
message.setSubject("Testing Subject");
// Send the actual HTML message, as big as you like
message.setContent(
"<h1>This is actual message embedded in HTML tags</h1>",
"text/html");
// Send message
Transport.send(message);
System.out.println("Sent message successfully....");
} catch (MessagingException e) {
e.printStackTrace();
throw new RuntimeException(e);
}
}
}Karena kami menggunakan server SMTP yang disediakan oleh penyedia host JangoSMTP, kami perlu mengautentikasi nama pengguna dan kata sandi. Kelas javax.mail.PasswordAuthentication digunakan untuk mengotentikasi kata sandi.
Kompilasi dan Jalankan
Sekarang kelas kita sudah siap, mari kita kompilasi kelas di atas. Saya telah menyimpan kelas SendHTMLEmail.java ke direktori:/home/manisha/JavaMailAPIExercise. Kita membutuhkan jars javax.mail.jar dan activation.jar di classpath. Jalankan perintah di bawah ini untuk mengkompilasi kelas (kedua jars ditempatkan di direktori / home / manisha /) dari command prompt:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendHTMLEmail.javaSekarang kelas telah dikompilasi, jalankan perintah di bawah ini untuk menjalankan:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendHTMLEmailVerify Output
You should see the following message on the command console:
Sent message successfully....As I'm sending an email to my gmail address through JangoSMTP, the following mail would be received in my gmail account inbox:
Here is an example to send an HTML email from your machine with inline image. Here we have used JangoSMTP server via which emails are sent to our destination email address. The setup is explained in the Environment Setup chapter.
To send a email with an inline image, the steps followed are:
Get a Session
Create a default MimeMessage object and set From, To, Subject in the message.
Create a MimeMultipart object.
In our example we will have an HTML part and an Image in the email. So first create the HTML content and set it in the multipart object as:
// first part (the html) BodyPart messageBodyPart = new MimeBodyPart(); String htmlText = "<H1>Hello</H1><img src=\"cid:image\">"; messageBodyPart.setContent(htmlText, "text/html"); // add it multipart.addBodyPart(messageBodyPart);Next add the image by creating a Datahandler as follows:
// second part (the image) messageBodyPart = new MimeBodyPart(); DataSource fds = new FileDataSource( "/home/manisha/javamail-mini-logo.png"); messageBodyPart.setDataHandler(new DataHandler(fds)); messageBodyPart.setHeader("Content-ID", "<image>");Next set the multipart in the message as follows:
message.setContent(multipart);Send the message using the Transport object.
Create Java Class
Create a java class file SendInlineImagesInEmail, the contents of which are as follows:
package com.tutorialspoint;
import java.util.Properties;
import javax.activation.DataHandler;
import javax.activation.DataSource;
import javax.activation.FileDataSource;
import javax.mail.BodyPart;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMultipart;
public class SendInlineImagesInEmail {
public static void main(String[] args) {
// Recipient's email ID needs to be mentioned.
String to = "[email protected]";
// Sender's email ID needs to be mentioned
String from = "[email protected]";
final String username = "manishaspatil";//change accordingly
final String password = "******";//change accordingly
// Assuming you are sending email through relay.jangosmtp.net
String host = "relay.jangosmtp.net";
Properties props = new Properties();
props.put("mail.smtp.auth", "true");
props.put("mail.smtp.starttls.enable", "true");
props.put("mail.smtp.host", host);
props.put("mail.smtp.port", "25");
Session session = Session.getInstance(props,
new javax.mail.Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(username, password);
}
});
try {
// Create a default MimeMessage object.
Message message = new MimeMessage(session);
// Set From: header field of the header.
message.setFrom(new InternetAddress(from));
// Set To: header field of the header.
message.setRecipients(Message.RecipientType.TO,
InternetAddress.parse(to));
// Set Subject: header field
message.setSubject("Testing Subject");
// This mail has 2 part, the BODY and the embedded image
MimeMultipart multipart = new MimeMultipart("related");
// first part (the html)
BodyPart messageBodyPart = new MimeBodyPart();
String htmlText = "<H1>Hello</H1><img src=\"cid:image\">";
messageBodyPart.setContent(htmlText, "text/html");
// add it
multipart.addBodyPart(messageBodyPart);
// second part (the image)
messageBodyPart = new MimeBodyPart();
DataSource fds = new FileDataSource(
"/home/manisha/javamail-mini-logo.png");
messageBodyPart.setDataHandler(new DataHandler(fds));
messageBodyPart.setHeader("Content-ID", "<image>");
// add image to the multipart
multipart.addBodyPart(messageBodyPart);
// put everything together
message.setContent(multipart);
// Send message
Transport.send(message);
System.out.println("Sent message successfully....");
} catch (MessagingException e) {
throw new RuntimeException(e);
}
}
}As we are using the SMTP server provided by the host provider JangoSMTP, we need to authenticate the username and password. The javax.mail.PasswordAuthentication class is used to authenticate the password.
Compile and Run
Now that our class is ready, let us compile the above class. I've saved the class SendInlineImagesInEmail.java to directory : /home/manisha/JavaMailAPIExercise. We would need the jars javax.mail.jar and activation.jar in the classpath. Execute the command below to compile the class (both the jars are placed in /home/manisha/ directory) from command prompt:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendInlineImagesInEmail.javaNow that the class is compiled, execute the below command to run:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendInlineImagesInEmailVerify Output
You should see the following message on the command console:
Sent message successfully....As I'm sending an email to my gmail address through JangoSMTP, the following mail would be received in my gmail account inbox:
There are two aspects to which needs to understood before proceeding with this chapter. They are Check and Fetch.
Checking an email in JavaMail is a process where we open the respective folder in the mailbox and get each message. Here we only check the header of each message i.e the From, To, subject. Content is not read.
Fetching an email in JavaMail is a process where we open the respective folder in the mailbox and get each message. Alongwith the header we also read the content by recognizing the content-type.
To check or fetch an email using JavaMail API, we would need POP or IMAP servers. To check and fetch the emails, Folder and Store classes are needed. Here we have used GMAIL's POP3 server (pop.gmail.com). In this chapter will learn how to check emails using JavaMail API. Fetching shall be covered in the subsequent chapters. To check emails:
Get a Session
Create pop3 Store object and connect with pop server.
Create folder object. Open the appropriate folder in your mailbox.
Get your messages.
Close the Store and Folder objects.
Create Java Class
Create a java class file CheckingMails, the contents of which are as follows:
package com.tutorialspoint;
import java.util.Properties;
import javax.mail.Folder;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.NoSuchProviderException;
import javax.mail.Session;
import javax.mail.Store;
public class CheckingMails {
public static void check(String host, String storeType, String user,
String password)
{
try {
//create properties field
Properties properties = new Properties();
properties.put("mail.pop3.host", host);
properties.put("mail.pop3.port", "995");
properties.put("mail.pop3.starttls.enable", "true");
Session emailSession = Session.getDefaultInstance(properties);
//create the POP3 store object and connect with the pop server
Store store = emailSession.getStore("pop3s");
store.connect(host, user, password);
//create the folder object and open it
Folder emailFolder = store.getFolder("INBOX");
emailFolder.open(Folder.READ_ONLY);
// retrieve the messages from the folder in an array and print it
Message[] messages = emailFolder.getMessages();
System.out.println("messages.length---" + messages.length);
for (int i = 0, n = messages.length; i < n; i++) {
Message message = messages[i];
System.out.println("---------------------------------");
System.out.println("Email Number " + (i + 1));
System.out.println("Subject: " + message.getSubject());
System.out.println("From: " + message.getFrom()[0]);
System.out.println("Text: " + message.getContent().toString());
}
//close the store and folder objects
emailFolder.close(false);
store.close();
} catch (NoSuchProviderException e) {
e.printStackTrace();
} catch (MessagingException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
String host = "pop.gmail.com";// change accordingly
String mailStoreType = "pop3";
String username = "[email protected]";// change accordingly
String password = "*****";// change accordingly
check(host, mailStoreType, username, password);
}
}Compile and Run
Now that our class is ready, let us compile the above class. I've saved the class CheckingMails.java to directory : /home/manisha/JavaMailAPIExercise. We would need the jars javax.mail.jar and activation.jar in the classpath. Execute the command below to compile the class (both the jars are placed in /home/manisha/ directory) from command prompt:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: CheckingMails.javaNow that the class is compiled, execute the below command to run:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: CheckingMailsVerify Output
You should see the following message on the command console:
messages.length---4
---------------------------------
Email Number 1
Subject: Test Mail--Fetch
From: <[email protected]>
Text: javax.mail.internet.MimeMultipart@327a5b7f
---------------------------------
Email Number 2
Subject: testing ----checking simple email
From: <[email protected]>
Text: javax.mail.internet.MimeMultipart@7f0d08bc
---------------------------------
Email Number 3
Subject: Email with attachment
From: <[email protected]>
Text: javax.mail.internet.MimeMultipart@30b8afce
---------------------------------
Email Number 4
Subject: Email with Inline image
From: <[email protected]>
Text: javax.mail.internet.MimeMultipart@2d1e165fHere we have printed the number of messages in the INBOX which is 4 in this case. We have also printed Subject, From address and Text for each email message.
In the previous chapter we learnt how to check emails. Now let us see how to fetch each email and read its content. Let us write a Java class FetchingEmail which will read following types of emails:
Simple email
Email with attachment
Email with inline image
Basic steps followed in the code are as below:
Get the Session object.
Create POP3 store object and connect to the store.
Create Folder object and open the appropriate folder in your mailbox.
Retrieve messages.
Close the folder and store objects respectively.
Create Java Class
Create a java class file FetchingEmail, contents of which are as below:
package com.tutorialspoint;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Date;
import java.util.Properties;
import javax.mail.Address;
import javax.mail.Folder;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Multipart;
import javax.mail.NoSuchProviderException;
import javax.mail.Part;
import javax.mail.Session;
import javax.mail.Store;
public class FetchingEmail {
public static void fetch(String pop3Host, String storeType, String user,
String password) {
try {
// create properties field
Properties properties = new Properties();
properties.put("mail.store.protocol", "pop3");
properties.put("mail.pop3.host", pop3Host);
properties.put("mail.pop3.port", "995");
properties.put("mail.pop3.starttls.enable", "true");
Session emailSession = Session.getDefaultInstance(properties);
// emailSession.setDebug(true);
// create the POP3 store object and connect with the pop server
Store store = emailSession.getStore("pop3s");
store.connect(pop3Host, user, password);
// create the folder object and open it
Folder emailFolder = store.getFolder("INBOX");
emailFolder.open(Folder.READ_ONLY);
BufferedReader reader = new BufferedReader(new InputStreamReader(
System.in));
// retrieve the messages from the folder in an array and print it
Message[] messages = emailFolder.getMessages();
System.out.println("messages.length---" + messages.length);
for (int i = 0; i < messages.length; i++) {
Message message = messages[i];
System.out.println("---------------------------------");
writePart(message);
String line = reader.readLine();
if ("YES".equals(line)) {
message.writeTo(System.out);
} else if ("QUIT".equals(line)) {
break;
}
}
// close the store and folder objects
emailFolder.close(false);
store.close();
} catch (NoSuchProviderException e) {
e.printStackTrace();
} catch (MessagingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
String host = "pop.gmail.com";// change accordingly
String mailStoreType = "pop3";
String username =
"[email protected]";// change accordingly
String password = "*****";// change accordingly
//Call method fetch
fetch(host, mailStoreType, username, password);
}
/*
* This method checks for content-type
* based on which, it processes and
* fetches the content of the message
*/
public static void writePart(Part p) throws Exception {
if (p instanceof Message)
//Call methos writeEnvelope
writeEnvelope((Message) p);
System.out.println("----------------------------");
System.out.println("CONTENT-TYPE: " + p.getContentType());
//check if the content is plain text
if (p.isMimeType("text/plain")) {
System.out.println("This is plain text");
System.out.println("---------------------------");
System.out.println((String) p.getContent());
}
//check if the content has attachment
else if (p.isMimeType("multipart/*")) {
System.out.println("This is a Multipart");
System.out.println("---------------------------");
Multipart mp = (Multipart) p.getContent();
int count = mp.getCount();
for (int i = 0; i < count; i++)
writePart(mp.getBodyPart(i));
}
//check if the content is a nested message
else if (p.isMimeType("message/rfc822")) {
System.out.println("This is a Nested Message");
System.out.println("---------------------------");
writePart((Part) p.getContent());
}
//check if the content is an inline image
else if (p.isMimeType("image/jpeg")) {
System.out.println("--------> image/jpeg");
Object o = p.getContent();
InputStream x = (InputStream) o;
// Construct the required byte array
System.out.println("x.length = " + x.available());
int i = 0;
byte[] bArray = new byte[x.available()];
while ((i = (int) ((InputStream) x).available()) > 0) {
int result = (int) (((InputStream) x).read(bArray));
if (result == -1)
break;
}
FileOutputStream f2 = new FileOutputStream("/tmp/image.jpg");
f2.write(bArray);
}
else if (p.getContentType().contains("image/")) {
System.out.println("content type" + p.getContentType());
File f = new File("image" + new Date().getTime() + ".jpg");
DataOutputStream output = new DataOutputStream(
new BufferedOutputStream(new FileOutputStream(f)));
com.sun.mail.util.BASE64DecoderStream test =
(com.sun.mail.util.BASE64DecoderStream) p
.getContent();
byte[] buffer = new byte[1024];
int bytesRead;
while ((bytesRead = test.read(buffer)) != -1) {
output.write(buffer, 0, bytesRead);
}
}
else {
Object o = p.getContent();
if (o instanceof String) {
System.out.println("This is a string");
System.out.println("---------------------------");
System.out.println((String) o);
}
else if (o instanceof InputStream) {
System.out.println("This is just an input stream");
System.out.println("---------------------------");
InputStream is = (InputStream) o;
is = (InputStream) o;
int c;
while ((c = is.read()) != -1)
System.out.write(c);
}
else {
System.out.println("This is an unknown type");
System.out.println("---------------------------");
System.out.println(o.toString());
}
}
}
/*
* This method would print FROM,TO and SUBJECT of the message
*/
public static void writeEnvelope(Message m) throws Exception {
System.out.println("This is the message envelope");
System.out.println("---------------------------");
Address[] a;
// FROM
if ((a = m.getFrom()) != null) {
for (int j = 0; j < a.length; j++)
System.out.println("FROM: " + a[j].toString());
}
// TO
if ((a = m.getRecipients(Message.RecipientType.TO)) != null) {
for (int j = 0; j < a.length; j++)
System.out.println("TO: " + a[j].toString());
}
// SUBJECT
if (m.getSubject() != null)
System.out.println("SUBJECT: " + m.getSubject());
}
}You can set the debug on by uncommenting the statement emailSession.setDebug(true);
Compile and Run
Now that our class is ready, let us compile the above class. I've saved the class FetchingEmail.java to directory : /home/manisha/JavaMailAPIExercise. We would need the jars javax.mail.jar and activation.jar in the classpath. Execute the command below to compile the class (both the jars are placed in /home/manisha/ directory) from command prompt:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: FetchingEmail.javaNow that the class is compiled, execute the below command to run:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: FetchingEmailVerify Output
You should see the following message on the command console:
messages.length---3
---------------------------------
This is the message envelope
---------------------------
FROM: XYZ <[email protected]>
TO: ABC <[email protected]>
SUBJECT: Simple Message
----------------------------
CONTENT-TYPE: multipart/alternative; boundary=047d7b343d6ad3e4ea04e8ec6579
This is a Multipart
---------------------------
----------------------------
CONTENT-TYPE: text/plain; charset=ISO-8859-1
This is plain text
---------------------------
Hi am a simple message string....
--
Regards
xyz
This is the message envelope
---------------------------
FROM: XYZ <[email protected]>
TO: ABC <[email protected]>
SUBJECT: Attachement
----------------------------
CONTENT-TYPE: multipart/mixed; boundary=047d7b343d6a99180904e8ec6751
This is a Multipart
---------------------------
----------------------------
CONTENT-TYPE: text/plain; charset=ISO-8859-1
This is plain text
---------------------------
Hi I've an attachment.Please check
--
Regards
XYZ
----------------------------
CONTENT-TYPE: application/octet-stream; name=sample_attachement
This is just an input stream
---------------------------
Submit your Tutorials, White Papers and Articles into our Tutorials Directory. This is a tutorials database where we are keeping all the tutorials shared by the internet community for the benefit of others.
This is the message envelope
---------------------------
FROM: XYZ <[email protected]>
TO: ABC <[email protected]>
SUBJECT: Inline Image
----------------------------
CONTENT-TYPE: multipart/related; boundary=f46d04182582be803504e8ece94b
This is a Multipart
---------------------------
----------------------------
CONTENT-TYPE: text/plain; charset=ISO-8859-1
This is plain text
---------------------------
Hi I've an inline image
[image: Inline image 3]
--
Regards
XYZ
----------------------------
CONTENT-TYPE: image/png; name="javamail-mini-logo.png"
content typeimage/png; name="javamail-mini-logo.png"Here you can see there are three emails in our mailbox. First a simple mail with message "Hi am a simple message string....". The second mail has an attachment. The contents of the attachment are also printed as seen above. The third mail has an inline image.
Kami akan memodifikasi CheckingMails.java kami dari bab Memeriksa Email . Isinya sebagai berikut:
package com.tutorialspoint;
import java.util.Properties;
import javax.mail.Authenticator;
import javax.mail.Folder;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.NoSuchProviderException;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Store;
public class CheckingMails {
public static void check(String host, String storeType, String user,
String password)
{
try {
// create properties field
Properties properties = new Properties();
properties.put("mail.pop3s.host", host);
properties.put("mail.pop3s.port", "995");
properties.put("mail.pop3s.starttls.enable", "true");
// Setup authentication, get session
Session emailSession = Session.getInstance(properties,
new javax.mail.Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(
"[email protected]", "manisha123");
}
});
// emailSession.setDebug(true);
// create the POP3 store object and connect with the pop server
Store store = emailSession.getStore("pop3s");
store.connect();
// create the folder object and open it
Folder emailFolder = store.getFolder("INBOX");
emailFolder.open(Folder.READ_ONLY);
// retrieve the messages from the folder in an array and print it
Message[] messages = emailFolder.getMessages();
System.out.println("messages.length---" + messages.length);
for (int i = 0, n = messages.length; i < n; i++) {
Message message = messages[i];
System.out.println("---------------------------------");
System.out.println("Email Number " + (i + 1));
System.out.println("Subject: " + message.getSubject());
System.out.println("From: " + message.getFrom()[0]);
System.out.println("Text: " + message.getContent().toString());
}
// close the store and folder objects
emailFolder.close(false);
store.close();
} catch (NoSuchProviderException e) {
e.printStackTrace();
} catch (MessagingException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
String host = "pop.gmail.com";// change accordingly
String mailStoreType = "pop3";
String username = "[email protected]";// change accordingly
String password = "*****";// change accordingly
check(host, mailStoreType, username, password);
}
}Anda bisa menyetel debug dengan menghapus komentar pernyataan emailSession.setDebug (true);
Kompilasi dan Jalankan
Sekarang kelas kita sudah siap, mari kita kompilasi kelas di atas. Saya telah menyimpan kelas CheckingMails.java ke direktori:/home/manisha/JavaMailAPIExercise. Kita membutuhkan jars javax.mail.jar dan activation.jar di classpath. Jalankan perintah di bawah ini untuk mengkompilasi kelas (kedua jars ditempatkan di direktori / home / manisha /) dari command prompt:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: CheckingMails.javaSekarang kelas telah dikompilasi, jalankan perintah di bawah ini untuk menjalankan:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: CheckingMailsVerifikasi Output
Anda dapat melihat pesan serupa seperti di bawah ini di konsol perintah:
messages.length---3
---------------------------------
Email Number 1
Subject: Today is a nice day
From: XYZ <[email protected]>
Text: javax.mail.internet.MimeMultipart@45f676cb
---------------------------------
Email Number 2
Subject: hiiii....
From: XYZ <[email protected]>
Text: javax.mail.internet.MimeMultipart@37f12d4f
---------------------------------
Email Number 3
Subject: helloo
From: XYZ <[email protected]>
Text: javax.mail.internet.MimeMultipart@3ad5ba3aPada bab ini kita akan melihat bagaimana membalas email menggunakan JavaMail API. Langkah-langkah dasar yang diikuti dalam program di bawah ini adalah:
Dapatkan objek Sesi dengan detail server POP dan SMTP di properti. Kami memerlukan detail POP untuk mengambil pesan dan detail SMTP untuk mengirim pesan.
Buat objek toko POP3 dan hubungkan ke toko.
Buat objek Folder dan buka folder yang sesuai di kotak surat Anda.
Ambil pesan.
Ulangi pesan dan ketik "Y" atau "y" jika Anda ingin membalas.
Dapatkan semua informasi (Kepada, Dari, Subjek, Konten) pesan.
Buat pesan balasan, menggunakan metode Message.reply (). Metode ini mengkonfigurasi Pesan baru dengan penerima dan subjek yang tepat. Metode ini mengambil parameter boolean yang menunjukkan apakah hanya membalas ke pengirim (salah) atau membalas ke semua (benar).
Atur Dari, Teks dan Balas ke dalam pesan dan kirimkan melalui contoh objek Transport.
Tutup Transport, folder dan simpan objek masing-masing.
Di sini kami telah menggunakan server JangoSMTP yang melaluinya email dikirim ke alamat email tujuan kami. Pengaturan dijelaskan di bab Pengaturan Lingkungan .
Buat Kelas Java
Buat file kelas java ReplyToEmail, yang isinya adalah sebagai berikut:
package com.tutorialspoint;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Date;
import java.util.Properties;
import javax.mail.Folder;
import javax.mail.Message;
import javax.mail.Session;
import javax.mail.Store;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
public class ReplyToEmail {
public static void main(String args[])
{
Date date = null;
Properties properties = new Properties();
properties.put("mail.store.protocol", "pop3");
properties.put("mail.pop3s.host", "pop.gmail.com");
properties.put("mail.pop3s.port", "995");
properties.put("mail.pop3.starttls.enable", "true");
properties.put("mail.smtp.auth", "true");
properties.put("mail.smtp.starttls.enable", "true");
properties.put("mail.smtp.host", "relay.jangosmtp.net");
properties.put("mail.smtp.port", "25");
Session session = Session.getDefaultInstance(properties);
// session.setDebug(true);
try
{
// Get a Store object and connect to the current host
Store store = session.getStore("pop3s");
store.connect("pop.gmail.com", "[email protected]",
"*****");//change the user and password accordingly
Folder folder = store.getFolder("inbox");
if (!folder.exists()) {
System.out.println("inbox not found");
System.exit(0);
}
folder.open(Folder.READ_ONLY);
BufferedReader reader = new BufferedReader(new InputStreamReader(
System.in));
Message[] messages = folder.getMessages();
if (messages.length != 0) {
for (int i = 0, n = messages.length; i < n; i++) {
Message message = messages[i];
date = message.getSentDate();
// Get all the information from the message
String from = InternetAddress.toString(message.getFrom());
if (from != null) {
System.out.println("From: " + from);
}
String replyTo = InternetAddress.toString(message
.getReplyTo());
if (replyTo != null) {
System.out.println("Reply-to: " + replyTo);
}
String to = InternetAddress.toString(message
.getRecipients(Message.RecipientType.TO));
if (to != null) {
System.out.println("To: " + to);
}
String subject = message.getSubject();
if (subject != null) {
System.out.println("Subject: " + subject);
}
Date sent = message.getSentDate();
if (sent != null) {
System.out.println("Sent: " + sent);
}
System.out.print("Do you want to reply [y/n] : ");
String ans = reader.readLine();
if ("Y".equals(ans) || "y".equals(ans)) {
Message replyMessage = new MimeMessage(session);
replyMessage = (MimeMessage) message.reply(false);
replyMessage.setFrom(new InternetAddress(to));
replyMessage.setText("Thanks");
replyMessage.setReplyTo(message.getReplyTo());
// Send the message by authenticating the SMTP server
// Create a Transport instance and call the sendMessage
Transport t = session.getTransport("smtp");
try {
//connect to the SMTP server using transport instance
//change the user and password accordingly
t.connect("abc", "****");
t.sendMessage(replyMessage,
replyMessage.getAllRecipients());
} finally {
t.close();
}
System.out.println("message replied successfully ....");
// close the store and folder objects
folder.close(false);
store.close();
} else if ("n".equals(ans)) {
break;
}
}//end of for loop
} else {
System.out.println("There is no msg....");
}
} catch (Exception e) {
e.printStackTrace();
}
}
}Anda dapat menyetel debug dengan menghapus komentar pada pernyataan session.setDebug (true);
Kompilasi dan Jalankan
Sekarang kelas kita sudah siap, mari kita kompilasi kelas di atas. Saya telah menyimpan kelas ReplyToEmail.java ke direktori:/home/manisha/JavaMailAPIExercise. Kita membutuhkan jars javax.mail.jar dan activation.jar di classpath. Jalankan perintah di bawah ini untuk mengkompilasi kelas (kedua jars ditempatkan di direktori / home / manisha /) dari command prompt:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: ReplyToEmail.javaSekarang kelas telah dikompilasi, jalankan perintah berikut untuk menjalankan:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: ReplyToEmailVerifikasi Output
Anda akan melihat pesan berikut di konsol perintah:
From: ABC <[email protected]>
Reply-to: [email protected]
To: XYZ <[email protected]>
Subject: Hi today is a nice day
Sent: Thu Oct 17 15:58:37 IST 2013
Do you want to reply [y/n] : y
message replied successfully ....Periksa kotak masuk tujuan pengiriman surat. Dalam kasus kami, pesan yang diterima terlihat seperti di bawah ini:
Pada bab ini kita akan melihat bagaimana meneruskan email menggunakan JavaMail API. Langkah-langkah dasar yang diikuti dalam program di bawah ini adalah:
Dapatkan objek Sesi dengan detail server POP dan SMTP di properti. Kami memerlukan detail POP untuk mengambil pesan dan detail SMTP untuk mengirim pesan.
Buat objek toko POP3 dan hubungkan ke toko.
Buat objek Folder dan buka folder yang sesuai di kotak surat Anda.
Ambil pesan.
Ulangi pesan dan ketik "Y" atau "y" jika Anda ingin meneruskan.
Dapatkan semua informasi (Kepada, Dari, Subjek, Konten) pesan.
Bangun pesan penerusan dengan mengerjakan bagian-bagian yang menyusun pesan. Bagian pertama adalah teks pesan dan bagian kedua adalah pesan untuk diteruskan. Gabungkan keduanya menjadi multi bagian. Kemudian Anda menambahkan multi bagian ke pesan yang dialamatkan dengan benar dan mengirimkannya.
Tutup Transport, folder dan simpan objek masing-masing.
Di sini kami telah menggunakan server JangoSMTP yang melaluinya email dikirim ke alamat email tujuan kami. Pengaturan dijelaskan di bab Pengaturan Lingkungan .
Buat Kelas Java
Buat file kelas java ForwardEmail, yang isinya adalah sebagai berikut:
package com.tutorialspoint;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Date;
import java.util.Properties;
import javax.mail.BodyPart;
import javax.mail.Folder;
import javax.mail.Message;
import javax.mail.Multipart;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Store;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMultipart;
public class ForwardEmail {
public static void main(String[] args) {
Properties properties = new Properties();
properties.put("mail.store.protocol", "pop3");
properties.put("mail.pop3s.host", "pop.gmail.com");
properties.put("mail.pop3s.port", "995");
properties.put("mail.pop3.starttls.enable", "true");
properties.put("mail.smtp.auth", "true");
properties.put("mail.smtp.host", "relay.jangosmtp.net");
properties.put("mail.smtp.port", "25");
Session session = Session.getDefaultInstance(properties);
try {
// session.setDebug(true);
// Get a Store object and connect to the current host
Store store = session.getStore("pop3s");
store.connect("pop.gmail.com", "[email protected]",
"*****");//change the user and password accordingly
// Create a Folder object and open the folder
Folder folder = store.getFolder("inbox");
folder.open(Folder.READ_ONLY);
BufferedReader reader = new BufferedReader(new InputStreamReader(
System.in));
Message[] messages = folder.getMessages();
if (messages.length != 0) {
for (int i = 0, n = messages.length; i < n; i++) {
Message message = messages[i];
// Get all the information from the message
String from = InternetAddress.toString(message.getFrom());
if (from != null) {
System.out.println("From: " + from);
}
String replyTo = InternetAddress.toString(message
.getReplyTo());
if (replyTo != null) {
System.out.println("Reply-to: " + replyTo);
}
String to = InternetAddress.toString(message
.getRecipients(Message.RecipientType.TO));
if (to != null) {
System.out.println("To: " + to);
}
String subject = message.getSubject();
if (subject != null) {
System.out.println("Subject: " + subject);
}
Date sent = message.getSentDate();
if (sent != null) {
System.out.println("Sent: " + sent);
}
System.out.print("Do you want to reply [y/n] : ");
String ans = reader.readLine();
if ("Y".equals(ans) || "y".equals(ans)) {
Message forward = new MimeMessage(session);
// Fill in header
forward.setRecipients(Message.RecipientType.TO,
InternetAddress.parse(from));
forward.setSubject("Fwd: " + message.getSubject());
forward.setFrom(new InternetAddress(to));
// Create the message part
MimeBodyPart messageBodyPart = new MimeBodyPart();
// Create a multipart message
Multipart multipart = new MimeMultipart();
// set content
messageBodyPart.setContent(message, "message/rfc822");
// Add part to multi part
multipart.addBodyPart(messageBodyPart);
// Associate multi-part with message
forward.setContent(multipart);
forward.saveChanges();
// Send the message by authenticating the SMTP server
// Create a Transport instance and call the sendMessage
Transport t = session.getTransport("smtp");
try {
//connect to the SMTP server using transport instance
//change the user and password accordingly
t.connect("abc", "*****");
t.sendMessage(forward, forward.getAllRecipients());
} finally {
t.close();
}
System.out.println("message forwarded successfully....");
// close the store and folder objects
folder.close(false);
store.close();
}// end if
}// end for
}// end if
} catch (Exception e) {
e.printStackTrace();
}
}
}Anda dapat menyetel debug dengan menghapus komentar pada pernyataan session.setDebug (true);
Kompilasi dan Jalankan
Sekarang kelas kita sudah siap, mari kita kompilasi kelas di atas. Saya telah menyimpan kelas ForwardEmail.java ke direktori:/home/manisha/JavaMailAPIExercise. Kita membutuhkan jars javax.mail.jar dan activation.jar di classpath. Jalankan perintah di bawah ini untuk mengkompilasi kelas (kedua jars ditempatkan di direktori / home / manisha /) dari command prompt:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: ForwardEmail.javaSekarang kelas telah dikompilasi, jalankan perintah berikut untuk menjalankan:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: ForwardEmailVerifikasi Output
Anda akan melihat pesan berikut di konsol perintah:
From: ABC <[email protected]>
Reply-to: [email protected]
To: XYZ <[email protected]>
Subject: Hi today is a nice day
Sent: Thu Oct 17 15:58:37 IST 2013
Do you want to reply [y/n] : y
message forwarded successfully....Periksa kotak masuk tujuan pengiriman surat. Dalam kasus kami, pesan yang diteruskan akan terlihat seperti di bawah ini:
Di bab ini kita akan melihat bagaimana cara menghapus email menggunakan JavaMail API. Menghapus pesan melibatkan bekerja dengan Bendera yang terkait dengan pesan. Ada tanda berbeda untuk status berbeda, sebagian ditentukan sistem dan sebagian ditentukan pengguna. Bendera yang telah ditentukan sebelumnya ditentukan di kelas bagian dalam Flags.Flag dan didaftar di bawah ini:
Flags.Flag.ANSWERED
Flags.Flag.DELETED
Flags.Flag.DRAFT
Flags.Flag.FLAGGED
Flags.Flag.RECENT
Flags.Flag.SEEN
Flags.Flag.USER
Protokol POP hanya mendukung penghapusan pesan.
Langkah-langkah dasar yang diikuti dalam program hapus adalah:
Dapatkan objek Sesi dengan detail server POP dan SMTP di properti. Kami memerlukan detail POP untuk mengambil pesan dan detail SMTP untuk mengirim pesan.
Buat objek toko POP3 dan hubungkan ke toko.
Buat objek Folder dan buka folder yang sesuai di kotak surat Anda dalam mode READ_WRITE.
Mengambil pesan dari folder kotak masuk.
Iterasi melalui pesan dan ketik "Y" atau "y" jika Anda ingin menghapus pesan dengan menjalankan metode setFlag (Flags.Flag.DELETED, true) pada objek Message.
Pesan yang ditandai DIHAPUS sebenarnya tidak dihapus, sampai kita memanggil metode penghapusan () pada objek Folder, atau menutup folder dengan penghapusan yang disetel ke true.
Tutup objek toko.
Buat Kelas Java
Buat file kelas java ForwardEmail, yang isinya adalah sebagai berikut:
package com.tutorialspoint;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Properties;
import javax.mail.Flags;
import javax.mail.Folder;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.NoSuchProviderException;
import javax.mail.Session;
import javax.mail.Store;
public class DeleteEmail {
public static void delete(String pop3Host, String storeType, String user,
String password)
{
try
{
// get the session object
Properties properties = new Properties();
properties.put("mail.store.protocol", "pop3");
properties.put("mail.pop3s.host", pop3Host);
properties.put("mail.pop3s.port", "995");
properties.put("mail.pop3.starttls.enable", "true");
Session emailSession = Session.getDefaultInstance(properties);
// emailSession.setDebug(true);
// create the POP3 store object and connect with the pop server
Store store = emailSession.getStore("pop3s");
store.connect(pop3Host, user, password);
// create the folder object and open it
Folder emailFolder = store.getFolder("INBOX");
emailFolder.open(Folder.READ_WRITE);
BufferedReader reader = new BufferedReader(new InputStreamReader(
System.in));
// retrieve the messages from the folder in an array and print it
Message[] messages = emailFolder.getMessages();
System.out.println("messages.length---" + messages.length);
for (int i = 0; i < messages.length; i++) {
Message message = messages[i];
System.out.println("---------------------------------");
System.out.println("Email Number " + (i + 1));
System.out.println("Subject: " + message.getSubject());
System.out.println("From: " + message.getFrom()[0]);
String subject = message.getSubject();
System.out.print("Do you want to delete this message [y/n] ? ");
String ans = reader.readLine();
if ("Y".equals(ans) || "y".equals(ans)) {
// set the DELETE flag to true
message.setFlag(Flags.Flag.DELETED, true);
System.out.println("Marked DELETE for message: " + subject);
} else if ("n".equals(ans)) {
break;
}
}
// expunges the folder to remove messages which are marked deleted
emailFolder.close(true);
store.close();
} catch (NoSuchProviderException e) {
e.printStackTrace();
} catch (MessagingException e) {
e.printStackTrace();
} catch (IOException io) {
io.printStackTrace();
}
}
public static void main(String[] args) {
String host = "pop.gmail.com";// change accordingly
String mailStoreType = "pop3";
String username = "[email protected]";// change accordingly
String password = "*****";// change accordingly
delete(host, mailStoreType, username, password);
}
}Anda bisa menyetel debug dengan menghapus komentar pernyataan emailSession.setDebug (true);
Kompilasi dan Jalankan
Sekarang kelas kita sudah siap, mari kita kompilasi kelas di atas. Saya telah menyimpan kelas DeleteEmail.java ke direktori:/home/manisha/JavaMailAPIExercise. Kita membutuhkan jars javax.mail.jar dan activation.jar di classpath. Jalankan perintah di bawah ini untuk mengkompilasi kelas (kedua jars ditempatkan di direktori / home / manisha /) dari command prompt:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: DeleteEmail.javaSekarang kelas telah dikompilasi, jalankan perintah berikut untuk menjalankan:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: DeleteEmailVerifikasi Output
Anda akan melihat pesan berikut di konsol perintah:
messages.length---1
---------------------------------
Email Number 1
Subject: Testing
From: ABC <[email protected]>
Do you want to delete this message [y/n] ? y
Marked DELETE for message: TestingDi semua bab sebelumnya kami menggunakan server JangoSMTP untuk mengirim email. Pada bab ini kita akan mempelajari tentang server SMTP yang disediakan oleh Gmail. Gmail (antara lain) menawarkan penggunaan server SMTP publik mereka secara gratis.
Detail server SMTP Gmail dapat ditemukan di sini . Seperti yang Anda lihat di detailnya, kami dapat menggunakan koneksi TLS atau SSL untuk mengirim email melalui server SMTP Gmail.
Prosedur mengirim email menggunakan server SMTP Gmail sama seperti yang dijelaskan di bab Mengirim Email , kecuali bahwa kami akan mengubah server host. Sebagai prasyarat, alamat email pengirim harus merupakan akun gmail yang aktif. Mari kita coba contoh.
Buat Kelas Java
Buat file Java SendEmailUsingGMailSMTP, isinya sbb:
package com.tutorialspoint;
import java.util.Properties;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
public class SendEmailUsingGMailSMTP {
public static void main(String[] args) {
// Recipient's email ID needs to be mentioned.
String to = "[email protected]";//change accordingly
// Sender's email ID needs to be mentioned
String from = "[email protected]";//change accordingly
final String username = "abc";//change accordingly
final String password = "*****";//change accordingly
// Assuming you are sending email through relay.jangosmtp.net
String host = "smtp.gmail.com";
Properties props = new Properties();
props.put("mail.smtp.auth", "true");
props.put("mail.smtp.starttls.enable", "true");
props.put("mail.smtp.host", host);
props.put("mail.smtp.port", "587");
// Get the Session object.
Session session = Session.getInstance(props,
new javax.mail.Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(username, password);
}
});
try {
// Create a default MimeMessage object.
Message message = new MimeMessage(session);
// Set From: header field of the header.
message.setFrom(new InternetAddress(from));
// Set To: header field of the header.
message.setRecipients(Message.RecipientType.TO,
InternetAddress.parse(to));
// Set Subject: header field
message.setSubject("Testing Subject");
// Now set the actual message
message.setText("Hello, this is sample for to check send "
+ "email using JavaMailAPI ");
// Send message
Transport.send(message);
System.out.println("Sent message successfully....");
} catch (MessagingException e) {
throw new RuntimeException(e);
}
}
}Di sini host ditetapkan sebagai smtp.gmail.com dan port ditetapkan sebagai 587 . Di sini kami telah mengaktifkan koneksi TLS.
Kompilasi dan Jalankan
Sekarang kelas kita sudah siap, mari kita kompilasi kelas di atas. Saya telah menyimpan kelas SendEmailUsingGMailSMTP.java ke direktori:/home/manisha/JavaMailAPIExercise. Kita membutuhkan jars javax.mail.jar dan activation.jar di classpath. Jalankan perintah di bawah ini untuk mengkompilasi kelas (kedua jars ditempatkan di direktori / home / manisha /) dari command prompt:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmailUsingGMailSMTP.javaSekarang kelas telah dikompilasi, jalankan perintah di bawah ini untuk menjalankan:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmailUsingGMailSMTPVerifikasi Output
Anda akan melihat pesan berikut di konsol perintah:
Sent message successfully....Sejauh ini, kami telah bekerja di bab-bab sebelumnya kebanyakan dengan folder INBOX. Ini adalah folder default tempat sebagian besar email berada. Beberapa sistem mungkin menyebutnya sebagai INBOX dan beberapa lainnya mungkin menyebutnya dengan nama lain. Tapi, Anda selalu bisa mengaksesnya dari JavaMail API menggunakan nama INBOX.
JavaMail API mewakili folder sebagai instance dari kelas Folder abstrak:
public abstract class Folder extends ObjectKelas ini mendeklarasikan metode untuk meminta folder bernama dari server, menghapus pesan dari folder, mencari pesan tertentu di folder, mencantumkan pesan di folder, dan sebagainya.
Membuka Folder
Kami tidak dapat membuat folder secara langsung karena satu-satunya konstruktor di kelas Folder yang dilindungi . Kita bisa mendapatkan Folder dari:
satu sesi
sebuah toko
atau Folder lain
Semua kelas di atas memiliki metode getFolder () yang serupa dengan tanda tangan serupa:
public abstract Folder getFolder(String name) throws MessagingExceptionBeberapa metode yang membantu mendapatkan objek Folder adalah:
| metode | Deskripsi |
|---|---|
| boolean ada () | Memeriksa apakah folder tersebut benar-benar ada. Gunakan metode ini sebelum mendapatkan objek Folder. |
| abstrak kosong terbuka (mode int) | Saat Anda mendapatkan Folder , folder tersebut ditutup. Gunakan metode ini untuk membukanya. mode dapat berupa Folder.READ_ONLY atau Folder.READ_WRITE. |
| abstrak boolean isOpen () | Metode ini mengembalikan nilai true jika folder terbuka, false jika ditutup |
| close void abstrak (penghapusan boolean) | Tutup foldernya. Jika penghapusan dari argumen adalah benar , setiap pesan yang dihapus di folder dihapus dari file yang sebenarnya di server. Jika tidak, mereka hanya ditandai sebagai dihapus , tetapi pesan masih bisa dibatalkan penghapusannya. |
Info Folder Dasar
Berikut adalah beberapa metode di kelas Folder yang mengembalikan informasi dasar tentang folder:
| metode | Deskripsi |
|---|---|
| abstrak String getName () | Mengembalikan nama folder, seperti "TutorialsPoint Mail" |
| abstrak String getFullName () | Mengembalikan nama hierarki lengkap dari root seperti "books / Manisha / TutorialsPoint Mail". |
| URLName getURLName () | Kembalikan URLName yang mewakili folder ini. |
| Abstrak Folder getParent () | Mengembalikan nama folder yang berisi folder ini, yaitu folder induk. Misalnya "Manisha" dari contoh "TutorialsPoint Mail" sebelumnya. |
| abstrak int getType () | Mengembalikan int yang menunjukkan apakah folder tersebut dapat berisi pesan dan / atau folder lain. |
| int getMode () | Ia mengembalikan salah satu dari dua konstanta bernama Folder.READ_ONLY atau Folder.READ_WRITE atau -1 ketika mode tidak diketahui. |
| Toko getStore () | Mengembalikan objek Store dari mana folder ini diambil. |
| abstrak char getSeparator () | Kembalikan karakter pembatas yang memisahkan nama jalur Folder ini dari nama subfolder langsung. |
Mengelola Folder
Berikut adalah beberapa metode yang membantu mengelola Folder:
| metode | Deskripsi |
|---|---|
| pembuatan boolean abstrak (tipe int) | Ini membuat folder baru di folder Store ini. Dimana jenisnya adalah: Folder.HOLDS_MESSAGES atau Folder.HOLDS_FOLDERS. Mengembalikan nilai benar jika folder berhasil dibuat jika tidak mengembalikan nilai salah . |
| penghapusan boolean abstrak (boolean recurse) | Ini menghapus folder hanya jika folder tersebut ditutup. Jika tidak, ini akan melontarkan IllegalStateException . Jika recurse adalah benar , maka subfolder akan dihapus. |
| abstrak boolean renameTo (Folder f) | Ini mengubah nama folder ini. Folder harus ditutup untuk diganti namanya. Jika tidak, IllegalStateException akan muncul. |
Mengelola Pesan di Folder
Berikut adalah beberapa metode yang membantu mengelola pesan di Folder:
| metode | Deskripsi |
|---|---|
| abstract void appendMessages (pesan [] pesan) | Sesuai namanya, pesan dalam array ditempatkan di akhir folder ini. |
| batal copyMessages (Pesan [] pesan, tujuan Folder) | Ini menyalin pesan dari folder ini ke dalam folder tertentu yang diberikan sebagai argumen. |
| Abstrak Pesan [] hapus () | Untuk menghapus pesan dari folder, setel flag Flags.Flag.DELETED ke true. Untuk secara fisik menghapus pesan yang dihapus dari folder, Anda harus memanggil metode ini. |
Membuat Daftar Isi Folder
Ada empat metode untuk membuat daftar folder yang berisi folder:
| metode | Deskripsi |
|---|---|
| Daftar [] folder () | Ini mengembalikan array yang mencantumkan folder yang berisi folder ini. |
| Folder [] listSubscribed () | Ini mengembalikan array yang mencantumkan semua folder langganan yang berisi folder ini. |
| daftar Folder [] abstrak (Pola string) | Ini mirip dengan metode list () kecuali yang memungkinkan Anda menentukan pola. Polanya adalah string yang memberi nama folder yang cocok. |
| Folder [] listSubscribed (Pola string) | Ini mirip dengan metode listSubscribed () kecuali bahwa metode ini memungkinkan Anda menentukan pola. Polanya adalah string yang memberi nama folder yang cocok. |
Memeriksa Mail
| metode | Deskripsi |
|---|---|
| abstract int getMessageCount () | Metode ini dapat dijalankan pada folder terbuka atau tertutup. Namun, dalam kasus folder tertutup, metode ini mungkin (atau mungkin tidak) mengembalikan -1 untuk menunjukkan bahwa jumlah pesan yang tepat tidak tersedia dengan mudah. |
| abstrak boolean hasNewMessages () | Ini mengembalikan nilai true jika pesan baru telah ditambahkan ke folder sejak terakhir dibuka. |
| int getNewMessageCount () | Ia mengembalikan jumlah pesan baru dengan memeriksa pesan di folder yang bendera TERBARU disetel. |
| int getUnreadMessageCount () | Ini dapat dijalankan pada folder terbuka atau tertutup. Namun, dalam kasus folder tertutup, itu mungkin mengembalikan -1 untuk menunjukkan bahwa jawaban sebenarnya akan terlalu mahal untuk diperoleh. |
Mendapatkan Pesan dari Folder
Kelas Folder menyediakan empat metode untuk mengambil pesan dari folder terbuka:
| metode | Deskripsi |
|---|---|
| abstrak Pesan getMessage (int messageNumber) | Ini mengembalikan pesan ke-n di folder. Pesan pertama di folder tersebut adalah nomor 1. |
| Pesan [] getMessages () | Ini mengembalikan larik objek Pesan yang mewakili semua pesan di folder ini. |
| Pesan [] getMessages (int start, int end) | Ini mengembalikan larik objek Pesan dari folder, dimulai dengan awal dan diakhiri dengan akhir, inklusif. |
| Pesan [] getMessages (int [] messageNumbers) | Ini mengembalikan larik yang hanya berisi pesan-pesan yang secara khusus diidentifikasi dengan nomor dalam larik messageNumbers . |
| void fetch (Message [] messages, FetchProfile fp) | Ambil terlebih dahulu item yang ditentukan dalam FetchProfile untuk Pesan tertentu. Argumen FetchProfile menentukan header mana dalam pesan yang akan diambil lebih dulu. |
Mencari Folder
Jika server mendukung pencarian (seperti yang dilakukan banyak server IMAP dan sebagian besar server POP tidak), maka mudah untuk mencari folder untuk pesan yang memenuhi kriteria tertentu. Kriteria dikodekan dalam objek SearchTerm. Berikut adalah dua metode pencarian:
| metode | Deskripsi |
|---|---|
| Pencarian [] pesan (istilah SearchTerm) | Cari Folder ini untuk pesan yang cocok dengan kriteria pencarian yang ditentukan. Mengembalikan larik yang berisi pesan yang cocok. Mengembalikan larik kosong jika tidak ditemukan kecocokan. |
| Pesan [] pencarian (istilah proses pencarian, pesan [] pesan) | Cari larik pesan yang diberikan untuk pesan yang cocok dengan kriteria pencarian yang ditentukan. Mengembalikan larik yang berisi pesan yang cocok. Mengembalikan larik kosong jika tidak ditemukan kecocokan. Objek Pesan yang ditentukan harus dimiliki folder ini. |
Bendera
Modifikasi bendera berguna saat Anda perlu mengubah tanda untuk seluruh kumpulan pesan di dalam Folder. Berikut adalah metode yang disediakan di kelas Folder:
| metode | Deskripsi |
|---|---|
| void setFlags (Pesan [] pesan, Bendera bendera, nilai boolean) | Menetapkan tanda yang ditentukan pada pesan yang ditentukan dalam larik. |
| void setFlags (int start, int end, Flags flag, nilai boolean) | Menetapkan bendera yang ditentukan pada pesan yang dinomori dari awal sampai akhir, baik mulai maupun akhir. |
| void setFlags (int [] messageNumbers, Flags flag, nilai boolean) | Menetapkan bendera yang ditentukan pada pesan yang nomor pesannya ada dalam larik. |
| Abstrak Bendera getPermanentFlags () | Mengembalikan bendera yang didukung folder ini untuk semua pesan. |
Kuota di JavaMail adalah jumlah atau jumlah pesan yang terbatas atau tetap di penyimpanan email. Setiap permintaan layanan Mail dihitung dalam kuota Panggilan API JavaMail. Layanan email dapat menerapkan kriteria kuota berikut:
Ukuran maksimum pesan email keluar, termasuk lampiran.
Ukuran maksimum pesan email masuk, termasuk lampiran.
Ukuran pesan maksimum ketika administrator adalah penerima
Untuk Manajemen kuota JavaMail memiliki kelas-kelas berikut:
| Kelas | Deskripsi |
|---|---|
| Kuota kelas umum | Kelas ini mewakili sekumpulan kuota untuk root kuota tertentu. Setiap root kuota memiliki sekumpulan resource, yang diwakili oleh kelas Quota.Resource. Setiap sumber daya memiliki nama (misalnya, "PENYIMPANAN"), penggunaan saat ini, dan batas penggunaan. Ini hanya memiliki satu metode setResourceLimit (Nama string, batas panjang) . |
| Quota.Resource kelas statis publik | Mewakili sumber daya individu di akar kuota. |
| antarmuka publik QuotaAwareStore | Antarmuka yang diterapkan oleh Toko yang mendukung kuota. Metode getQuota dan setQuota mendukung model kuota yang ditentukan oleh ekstensi IMAP QUOTA. GmailSSLStore, GmailStore, IMAPSSLStore, IMAPStore adalah kelas penerapan yang diketahui dari antarmuka ini. |
Mari kita lihat dan contoh di bagian berikut yang memeriksa nama penyimpanan surat, batas dan penggunaannya.
Buat Kelas Java
Buat file kelas java QuotaExample, yang isinya adalah sebagai berikut:
package com.tutorialspoint;
import java.util.Properties;
import javax.mail.Quota;
import javax.mail.Session;
import javax.mail.Store;
import com.sun.mail.imap.IMAPStore;
public class QuotaExample
{
public static void main(String[] args)
{
try
{
Properties properties = new Properties();
properties.put("mail.store.protocol", "imaps");
properties.put("mail.imaps.port", "993");
properties.put("mail.imaps.starttls.enable", "true");
Session emailSession = Session.getDefaultInstance(properties);
// emailSession.setDebug(true);
// create the IMAP3 store object and connect with the pop server
Store store = emailSession.getStore("imaps");
//change the user and password accordingly
store.connect("imap.gmail.com", "[email protected]", "*****");
IMAPStore imapStore = (IMAPStore) store;
System.out.println("imapStore ---" + imapStore);
//get quota
Quota[] quotas = imapStore.getQuota("INBOX");
//Iterate through the Quotas
for (Quota quota : quotas) {
System.out.println(String.format("quotaRoot:'%s'",
quota.quotaRoot));
//Iterate through the Quota Resource
for (Quota.Resource resource : quota.resources) {
System.out.println(String.format(
"name:'%s', limit:'%s', usage:'%s'", resource.name,
resource.limit, resource.usage));
}
}
} catch (Exception e)
{
e.printStackTrace();
}
}
}Berikut adalah koneksi ke layanan gmail melalui server IMAP (imap.gmail.com), karena IMAPStore mengimplementasikan QuotaAwareStore. Setelah Anda mendapatkan objek Store, ambil array Quota dan lakukan iterasi melaluinya dan cetak informasi yang relevan.
Kompilasi dan Jalankan
Sekarang kelas kita sudah siap, mari kita kompilasi kelas di atas. Saya telah menyimpan kelas QuotaExample.java ke direktori:/home/manisha/JavaMailAPIExercise. Kita membutuhkan jars javax.mail.jar dan activation.jar di classpath. Jalankan perintah di bawah ini untuk mengkompilasi kelas (kedua jars ditempatkan di direktori / home / manisha /) dari command prompt:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: QuotaExample.javaSekarang kelas telah dikompilasi, jalankan perintah di bawah ini untuk menjalankan:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: QuotaExampleVerifikasi Output
Anda akan melihat pesan serupa di konsol perintah:
imapStore ---imaps://abc%[email protected]
quotaRoot:''
name:'STORAGE', limit:'15728640', usage:'513'Sebuah pesan dapat terpental karena beberapa alasan. Masalah ini dibahas secara mendalam di rfc1211 . Hanya server yang dapat menentukan keberadaan kotak surat atau nama pengguna tertentu. Ketika server mendeteksi kesalahan, itu akan mengembalikan pesan yang menunjukkan alasan kegagalan kepada pengirim pesan asli.
Ada banyak standar Internet yang mencakup Pemberitahuan Status Pengiriman tetapi sejumlah besar server tidak mendukung standar baru ini, sebagai gantinya menggunakan teknik ad hoc untuk mengembalikan pesan kegagalan tersebut. Oleh karena itu, sangat sulit untuk menghubungkan pesan pentalan dengan pesan asli yang menyebabkan masalah.
JavaMail menyertakan dukungan untuk mengurai Pemberitahuan Status Pengiriman. Ada sejumlah teknik dan heuristik untuk mengatasi masalah ini. Salah satu teknik yang digunakan adalah Variable Envelope Return Paths. Anda dapat menyetel jalur pengembalian di amplop seperti yang ditunjukkan pada contoh di bawah ini. Ini adalah alamat tujuan pengiriman email bouncing. Anda mungkin ingin menyetel ini ke alamat umum, berbeda dari header Dari:, sehingga Anda dapat memproses pantulan jarak jauh. Ini dilakukan dengan menyetel properti mail.smtp.from di JavaMail.
Buat Kelas Java
Buat file kelas java SendEmail, yang isinya adalah sebagai berikut:
import java.util.Properties;
import javax.mail.Message;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
public class SendEmail {
public static void main(String[] args) throws Exception {
String smtpServer = "smtp.gmail.com";
int port = 587;
final String userid = "youraddress";//change accordingly
final String password = "*****";//change accordingly
String contentType = "text/html";
String subject = "test: bounce an email to a different address " +
"from the sender";
String from = "[email protected]";
String to = "[email protected]";//some invalid address
String bounceAddr = "[email protected]";//change accordingly
String body = "Test: get message to bounce to a separate email address";
Properties props = new Properties();
props.put("mail.smtp.auth", "true");
props.put("mail.smtp.starttls.enable", "true");
props.put("mail.smtp.host", smtpServer);
props.put("mail.smtp.port", "587");
props.put("mail.transport.protocol", "smtp");
props.put("mail.smtp.from", bounceAddr);
Session mailSession = Session.getInstance(props,
new javax.mail.Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(userid, password);
}
});
MimeMessage message = new MimeMessage(mailSession);
message.addFrom(InternetAddress.parse(from));
message.setRecipients(Message.RecipientType.TO, to);
message.setSubject(subject);
message.setContent(body, contentType);
Transport transport = mailSession.getTransport();
try {
System.out.println("Sending ....");
transport.connect(smtpServer, port, userid, password);
transport.sendMessage(message,
message.getRecipients(Message.RecipientType.TO));
System.out.println("Sending done ...");
} catch (Exception e) {
System.err.println("Error Sending: ");
e.printStackTrace();
}
transport.close();
}// end function main()
}Di sini kita dapat melihat bahwa properti mail.smtp.from disetel berbeda dari alamat from .
Kompilasi dan Jalankan
Sekarang kelas kita sudah siap, mari kita kompilasi kelas di atas. Saya telah menyimpan kelas SendEmail.java ke direktori:/home/manisha/JavaMailAPIExercise. Kita membutuhkan jars javax.mail.jar dan activation.jar di classpath. Jalankan perintah di bawah ini untuk mengkompilasi kelas (kedua jars ditempatkan di direktori / home / manisha /) dari command prompt:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmail.javaSekarang kelas telah dikompilasi, jalankan perintah di bawah ini untuk menjalankan:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmailVerifikasi Output
Anda akan melihat pesan berikut di konsol perintah:
Sending ....
Sending done ...SMTP adalah singkatan dari Simple Mail Transfer Protocol. Ini adalah standar Internet untuk transmisi surat elektronik (email) melalui jaringan Internet Protocol (IP). SMTP menggunakan TCP port 25. Sambungan SMTP yang diamankan dengan SSL dikenal dengan singkatan SMTPS, meskipun SMTPS bukanlah protokol tersendiri.
JavaMail API memiliki paket com.sun.mail.smtpyang bertindak sebagai penyedia protokol SMTP untuk mengakses server SMTP. Tabel berikut mencantumkan kelas yang termasuk dalam paket ini:
| Kelas | Deskripsi |
|---|---|
| SMTPMessage | Kelas ini adalah spesialisasi dari kelas MimeMessage yang memungkinkan Anda menentukan berbagai opsi dan parameter SMTP yang akan digunakan saat pesan ini dikirim melalui SMTP. |
| SMTPSSLTransport | Kelas ini mengimplementasikan kelas abstrak Transport menggunakan SMTP melalui SSL untuk pengiriman dan pengangkutan pesan. |
| SMTPTransport | Kelas ini mengimplementasikan kelas abstrak Transport menggunakan SMTP untuk pengiriman dan pengangkutan pesan. |
Tabel berikut mencantumkan pengecualian yang dilemparkan:
| Pengecualian | Deskripsi |
|---|---|
| SMTPAddressFailedException | Pengecualian ini dilemparkan ketika pesan tidak dapat dikirim. |
| SMTPAddressSucceededException | Pengecualian ini dirantai dari SendFailedException jika properti mail.smtp.reportsuccess benar. |
| SMTPSenderFailedException | Pengecualian ini dilemparkan ketika pesan tidak dapat dikirim. |
| SMTPSendFailedException | Pengecualian ini dilemparkan ketika pesan tidak dapat dikirim. Pengecualian termasuk alamat pengirim, yang ditolak oleh server email. |
Itu com.sun.mail.smtppenyedia menggunakan Otentikasi SMTP secara opsional. Untuk menggunakan otentikasi SMTP, Anda harus menyetel properti mail.smtp.auth atau memberikan SMTP Transport dengan nama pengguna dan kata sandi saat menyambung ke server SMTP. Anda dapat melakukannya dengan menggunakan salah satu pendekatan berikut:
Berikan objek Authenticator saat membuat Sesi email Anda dan berikan informasi nama pengguna dan sandi selama panggilan balik Authenticator. Properti mail.smtp.user dapat disetel untuk memberikan nama pengguna default untuk panggilan balik, tetapi kata sandi masih perlu diberikan secara eksplisit. Pendekatan ini memungkinkan Anda menggunakan metode pengiriman Transport statis untuk mengirim pesan. Sebagai contoh:
Transport.send(message);Panggil metode Transport connect secara eksplisit dengan argumen nama pengguna dan kata sandi. Sebagai contoh:
Transport tr = session.getTransport("smtp");
tr.connect(smtphost, username, password);
msg.saveChanges();
tr.sendMessage(msg, msg.getAllRecipients());
tr.close();Penyedia protokol SMTP mendukung properti berikut ini, yang dapat disetel di objek Sesi JavaMail. Properti selalu disetel sebagai string. Sebagai contoh:
props.put("mail.smtp.port", "587");IMAP adalah Akronim untuk Internet Message Access Protocol. Ini adalah protokol Internet Lapisan Aplikasi yang memungkinkan klien email mengakses email di server email jarak jauh. Server IMAP biasanya mendengarkan pada porta 143 yang terkenal. IMAP melalui SSL (IMAPS) ditetapkan ke nomor port 993.
IMAP mendukung mode operasi on-line dan off-line. Klien email yang menggunakan IMAP biasanya meninggalkan pesan di server sampai pengguna menghapusnya secara eksplisit.
Paket com.sun.mail.imapadalah penyedia protokol IMAP untuk JavaMail API yang menyediakan akses ke penyimpanan pesan IMAP. Tabel di bawah ini mencantumkan antarmuka dan kelas dari penyedia ini:
| Kelas / Antarmuka | Deskripsi |
|---|---|
| IMAPFolder.ProtocolCommand | Ini antarmuka sederhana untuk perintah protokol IMAP yang ditentukan pengguna. |
| ACL | Ini adalah kelas. Entri daftar kontrol akses untuk pengenal otentikasi tertentu (pengguna atau grup). |
| IMAPFolder | Kelas ini mengimplementasikan folder IMAP. |
| IMAPFolder.FetchProfileItem | Ini kelas untuk mengambil tajuk. |
| IMAPMessage | Kelas ini mengimplementasikan objek ReadableMime. |
| IMAPMessage.FetchProfileCondition | Kelas ini mengimplementasikan pengujian yang harus dilakukan pada setiap pesan di folder. |
| IMAPSSLStore | Kelas ini menyediakan akses ke penyimpanan pesan IMAP melalui SSL. |
| IMAPStore | Kelas ini menyediakan akses ke penyimpanan pesan IMAP. |
| Hak | Kelas ini mewakili sekumpulan hak untuk pengenal otentikasi (misalnya, pengguna atau grup). |
| Hak. Benar | Kelas batin ini mewakili hak individu. |
| SortTerm | Kriteria pengurutan tertentu, seperti yang ditentukan oleh RFC 5256. |
Beberapa poin yang perlu diperhatikan di atas penyedia ini:
Penyedia ini mendukung protokol IMAP4 dan IMAP4rev1.
IMAPStore yang terhubung memelihara kumpulan objek protokol IMAP untuk digunakan dalam berkomunikasi dengan server IMAP. Saat folder dibuka dan objek protokol IMAP baru diperlukan, IMAPStore akan menyediakannya dari kumpulan koneksi, atau membuatnya jika tidak ada yang tersedia. Ketika folder ditutup, objek protokol IMAP dikembalikan ke kumpulan koneksi jika kolam.
Objek IMAPStore terhubung mungkin atau mungkin tidak memelihara objek protokol IMAP terpisah yang menyediakan penyimpanan koneksi khusus ke server IMAP.
Post Office Protocol (POP) adalah protokol standar Internet lapisan aplikasi yang digunakan oleh klien email lokal untuk mengambil email dari server jauh melalui koneksi TCP / IP. POP mendukung persyaratan unduh dan hapus sederhana untuk akses ke kotak surat jauh. Server POP3 mendengarkan pada port 110 yang terkenal.
Paket com.sun.mail.pop3adalah penyedia protokol POP3 untuk JavaMail API yang menyediakan akses ke penyimpanan pesan POP3. Tabel di bawah ini mencantumkan kelas-kelas dalam paket ini:
| Nama | Deskripsi |
|---|---|
| POP3Folder | Folder POP3 (hanya bisa "INBOX"). |
| POP3Message | Pesan POP3. |
| POP3SSLStore | Penyimpanan Pesan POP3 menggunakan SSL. |
| POP3Store | Toko Pesan POP3. |
Beberapa poin yang perlu diperhatikan di atas penyedia ini:
Penyedia POP3 hanya mendukung satu folder bernama INBOX. Karena keterbatasan protokol POP3, banyak kapabilitas JavaMail API seperti pemberitahuan peristiwa, pengelolaan folder, pengelolaan tanda, dll. Tidak diperbolehkan.
Penyedia POP3 diakses melalui JavaMail API dengan menggunakan nama protokol pop3 atau URL dengan format pop3: // user: password @ host: port / INBOX " .
POP3 tidak mendukung tanda permanen. Misalnya, flag Flags.Flag.RECENT tidak akan pernah disetel untuk pesan POP3. Terserah aplikasi untuk menentukan pesan mana di kotak surat POP3 yang baru .
POP3 tidak mendukung metode Folder.expunge (). Untuk menghapus dan membuang pesan, setel flag Flags.Flag.DELETED pada pesan dan tutup folder menggunakan metode Folder.close (true).
POP3 tidak memberikan tanggal penerimaan , sehingga metode getReceivedDate akan mengembalikan null.
Saat header pesan POP3 diakses, penyedia POP3 menggunakan perintah TOP untuk mengambil semua header, yang kemudian disimpan dalam cache.
Saat konten pesan POP3 diakses, penyedia POP3 menggunakan perintah RETR untuk mengambil seluruh pesan.
The POP3Message.invalidate metode dapat digunakan untuk data yang invalidate cache tanpa menutup folder.