JavaMail API-빠른 가이드
JavaMail API는 메일 및 메시징 애플리케이션을 빌드하기 위해 플랫폼과 프로토콜에 독립적 인 프레임 워크를 제공합니다. JavaMail API는 메일 시스템을 구성하는 객체를 정의하는 추상 클래스 집합을 제공합니다. 전자 메시지를 읽고, 작성하고, 보내기위한 옵션 패키지 (표준 확장)입니다.
JavaMail은 시스템 구성 요소 및 인터페이스를 포함하여 메시징 시스템에 대한 인터페이스를 구성하는 데 사용되는 요소를 제공합니다. 이 사양은 특정 구현을 정의하지 않지만 JavaMail에는 RFC822 및 MIME 인터넷 메시징 표준을 구현하는 여러 클래스가 포함되어 있습니다. 이러한 클래스는 JavaMail 클래스 패키지의 일부로 제공됩니다.
다음은 JavaMail API에서 지원되는 일부 프로토콜입니다.
SMTP: 약어 Simple Mail Transfer Protocol. 이메일을 전달하는 메커니즘을 제공합니다.
POP: 약어 Post Office Protocol. POP는 인터넷에서 대부분의 사람들이 메일을 받기 위해 사용하는 메커니즘입니다. 각 사용자에 대한 단일 사서함에 대한 지원을 정의합니다. RFC 1939는이 프로토콜을 정의합니다.
IMAP: 약어 Internet Message Access Protocol. 메시지 수신을위한 고급 프로토콜입니다. 여러 사용자가 사서함을 공유 할 수있을뿐만 아니라 각 사용자에 대해 여러 사서함을 지원합니다. RFC 2060에 정의되어 있습니다.
MIME: 약어 Multipurpose Internet Mail Extensions. . 메일 전송 프로토콜이 아닙니다. 대신 전송되는 내용 (메시지 형식, 첨부 파일 등)을 정의합니다. 여기에는 RFC 822, RFC 2045, RFC 2046 및 RFC 2047 등 다양한 문서가 적용됩니다. JavaMail API 사용자는 일반적으로 이러한 형식에 대해 걱정할 필요가 없습니다. 그러나 이러한 형식은 존재하며 프로그램에서 사용됩니다.
NNTP and Others: 타사 제공 업체에서 제공하는 많은 프로토콜이 있습니다. 그중 일부는 NNTP (Network News Transfer Protocol), S / MIME (Secure Multipurpose Internet Mail Extensions) 등입니다.
이에 대한 자세한 내용은 다음 장에서 다룹니다.
건축물
위에서 언급했듯이 Java 애플리케이션은 JavaMail API를 사용하여 전자 메일을 작성, 전송 및 수신합니다. 다음 그림은 JavaMail의 아키텍처를 보여줍니다.
JavaMail API의 추상 메커니즘은 JDBC, JNDI 및 JMS와 같은 다른 J2EE API와 유사합니다. 위의 아키텍처 다이어그램에서 볼 수 있듯이 JavaMail API는 두 가지 주요 부분으로 나뉩니다.
응용 프로그램 독립 부분 : 응용 프로그램 구성 요소는 API (응용 프로그램 프로그래밍 인터페이스)를 사용하여 사용되는 기본 공급자 또는 프로토콜에 관계없이 메일 메시지를 보내고받습니다.
서비스 종속 부분 : SPI (서비스 공급자 인터페이스)는 SMTP, POP, IMAP 및 NNTP (Network News Transfer Protocol)와 같은 프로토콜 별 언어를 사용합니다. 전자 메일 서비스 공급자를 J2EE 플랫폼에 연결하는 데 사용됩니다.
Java 응용 프로그램을 사용하여 전자 메일을 보내는 것은 간단하지만 시작하려면 JavaMail API 과 Java Activation Framework (JAF) 컴퓨터에 설치됩니다.
당신은 필요합니다 JavaBeans Activation Framework (JAF)Java SE 6 이상을 사용하지 않는 경우에만 javax.activation 패키지 를 제공하는 확장입니다 .
Java의 표준 웹 사이트에서 최신 버전의 JavaMail (버전 1.5.0) 을 다운로드 할 수 있습니다 .
Java의 표준 웹 사이트에서 최신 버전의 JAF (버전 1.1.1) 를 다운로드 할 수 있습니다 .
이 파일을 다운로드하고 압축을 풀면 새로 생성 된 최상위 디렉토리에서 두 응용 프로그램에 대한 여러 jar 파일을 찾을 수 있습니다. 추가해야합니다.mail.jar 과 activation.jar CLASSPATH의 파일.
SMTP 서버
이메일을 보내려면 메일을 보내는 SMTP 서버가 있어야합니다. 다음 기술 중 하나를 사용하여 SMTP 서버를 가져올 수 있습니다.
Postfix 서버 (Ubuntu 용), Apache James 서버 (Java Apache Mail Enterprise Server) 등과 같은 SMTP 서버를 설치하고 사용합니다. (또는)
예 : JangoSMTP 사이트에서 제공하는 무료 SMTP 는 relay.jangosmtp.net (또는)입니다.
회사에서 제공하는 SMTP 서버 (예 : gmail, yahoo 등)를 사용하십시오.
다음 장의 예에서는 무료 JangoSMTP 서버를 사용하여 이메일을 전송했습니다. 이 사이트를 방문하여 계정을 만들고 이메일 주소를 구성 할 수 있습니다.
JavaMail API는 전자 메일 메시지를 보내고 읽고 삭제하는 데 사용되는 일부 인터페이스와 클래스로 구성됩니다. JavaMail API에는 많은 패키지가 있지만 Java Mail API에서 자주 사용되는 두 가지 주요 패키지 인 javax.mail 및 javax.mail.internet 패키지를 다룹니다 . 이러한 패키지에는 모든 JavaMail 핵심 클래스가 포함되어 있습니다. 그들은:
수업 | 기술 |
---|---|
javax.mail.Session | API의 키 클래스입니다. 다중 스레드 개체는 연결 팩토리를 나타냅니다. |
javax.mail.Message | 전자 메일 메시지를 모델링하는 추상 클래스입니다. 서브 클래스는 실제 구현을 제공합니다. |
javax.mail.Address | 메시지의 주소 (발신 및 수신 주소)를 모델링하는 추상 클래스입니다. 서브 클래스는 특정 구현을 제공합니다. |
javax.mail.Authenticator | 메일 서버에서 메일 자원을 보호하는 데 사용되는 추상 클래스입니다. |
javax.mail.Transport | 전자 메일 메시지를 보내기위한 메시지 전송 메커니즘을 모델링하는 추상 클래스입니다. |
javax.mail.Store | 메시지 저장 및 검색을 위해 메시지 저장소 및 해당 액세스 프로토콜을 모델링하는 추상 클래스입니다. 스토어는 폴더로 나뉩니다. |
javax.mail.Folder | 메일 메시지 폴더를 나타내는 추상 클래스입니다. 하위 폴더를 포함 할 수 있습니다. |
javax.mail.internet.MimeMessage | 메시지는 추상 클래스이므로 하위 클래스와 함께 작동해야합니다. 대부분의 경우 MimeMessage를 사용합니다. MimeMessage는 MIME 유형과 헤더를 이해하는 이메일 메시지입니다. |
javax.mail.internet.InternetAddress | 이 클래스는 RFC822 구문을 사용하는 인터넷 이메일 주소를 나타냅니다. 일반적인 주소 구문은 [email protected] 또는 Personal Name <[email protected]> 형식 입니다. |
다음은 간단한 이메일을 보내는 예입니다. 여기서는 이메일이 목적지 이메일 주소로 전송되는 JangoSMTP 서버를 사용했습니다. 설정은 환경 설정 장 에서 설명합니다 .
간단한 이메일을 보내는 방법은 다음과 같습니다.
세션 받기
기본 MimeMessage 개체를 만들고 메시지에서 From, To, Subject 를 설정 합니다.
실제 메시지를 다음과 같이 설정하십시오.
message.setText("your text goes here");
Transport 개체를 사용하여 메시지를 보냅니다.
자바 클래스 생성
자바 클래스 파일 만들기 SendEmail, 그 내용은 다음과 같습니다.
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);
}
}
}
호스트 공급자 JangoSMTP에서 제공하는 SMTP 서버를 사용하고 있으므로 사용자 이름과 비밀번호를 인증해야합니다. javax.mail.PasswordAuthentication의 클래스는 암호를 인증하는 데 사용됩니다.
컴파일 및 실행
이제 클래스가 준비되었으므로 위의 클래스를 컴파일 해 보겠습니다. 클래스 SendEmail.java를 디렉토리에 저장했습니다./home/manisha/JavaMailAPIExercise. 클래스 경로에 jars javax.mail.jar 및 activation.jar 이 필요합니다 . 아래 명령을 실행하여 명령 프롬프트에서 클래스를 컴파일하십시오 (두 jar 모두 / home / manisha / 디렉토리에 있음).
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmail.java
이제 클래스가 컴파일되었으므로 아래 명령을 실행하여 실행하십시오.
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmail
출력 확인
명령 콘솔에 다음 메시지가 표시되어야합니다.
Sent message successfully....
JangoSMTP를 통해 내 Gmail 주소로 이메일을 보낼 때 다음 메일이 내 Gmail 계정받은 편지함으로 수신됩니다.
다음은 컴퓨터에서 첨부 파일이있는 이메일을 보내는 예입니다. 로컬 시스템의 파일은file.txt/ home / manisha /에 배치되었습니다 . 여기서는 이메일이 목적지 이메일 주소로 전송되는 JangoSMTP 서버를 사용했습니다. 설정은 환경 설정 장 에서 설명합니다 .
인라인 이미지와 함께 이메일을 보내려면 다음 단계를 따르세요.
세션 받기
기본 MimeMessage 개체를 만들고 메시지에서 From, To, Subject 를 설정 합니다.
실제 메시지를 아래와 같이 설정하십시오.
messageBodyPart.setText("This is message body");
MimeMultipart 객체를 만듭니다. 실제 메시지가 설정된 위의 messageBodyPart를이 멀티 파트 객체에 추가합니다.
다음으로 다음과 같이 Datahandler를 만들어 첨부 파일을 추가합니다.
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);
다음으로 메시지에서 멀티 파트를 다음과 같이 설정합니다.
message.setContent(multipart);
Transport 개체를 사용하여 메시지를 보냅니다.
자바 클래스 생성
자바 클래스 파일 만들기 SendAttachmentInEmail, 그 내용은 다음과 같습니다.
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);
}
}
}
호스트 공급자 JangoSMTP에서 제공하는 SMTP 서버를 사용하고 있으므로 사용자 이름과 비밀번호를 인증해야합니다. javax.mail.PasswordAuthentication의 클래스는 암호를 인증하는 데 사용됩니다.
컴파일 및 실행
이제 클래스가 준비되었으므로 위의 클래스를 컴파일 해 보겠습니다. SendAttachmentInEmail.java 클래스를 디렉토리에 저장했습니다./home/manisha/JavaMailAPIExercise. 클래스 경로에 jars javax.mail.jar 및 activation.jar 이 필요합니다 . 아래 명령을 실행하여 명령 프롬프트에서 클래스를 컴파일하십시오 (두 jar 모두 / home / manisha / 디렉토리에 있음).
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendAttachmentInEmail.java
이제 클래스가 컴파일되었으므로 아래 명령을 실행하여 실행하십시오.
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendAttachmentInEmail
출력 확인
명령 콘솔에 다음 메시지가 표시되어야합니다.
Sent message successfully....
JangoSMTP를 통해 내 Gmail 주소로 이메일을 보낼 때 다음 메일이 내 Gmail 계정받은 편지함으로 수신됩니다.
다음은 컴퓨터에서 HTML 이메일을 보내는 예입니다. 여기서는 이메일이 목적지 이메일 주소로 전송되는 JangoSMTP 서버를 사용했습니다. 설정은 환경 설정 장 에서 설명합니다 .
이 예제는 간단한 이메일을 보내는 것과 매우 유사합니다. 단, 여기서는 setContent () 메서드를 사용하여 두 번째 인수가 "text / html"인 콘텐츠를 설정하여 HTML 콘텐츠가 메시지에 포함되도록 지정합니다. 이 예제를 사용하면 원하는만큼 큰 HTML 콘텐츠를 보낼 수 있습니다.
HTML 콘텐츠가 포함 된 이메일을 보내려면 다음 단계를 따르세요.
세션 받기
기본 MimeMessage 개체를 만들고 메시지에서 From, To, Subject 를 설정 합니다.
아래와 같이 setContent () 메서드를 사용하여 실제 메시지를 설정합니다.
message.setContent("<h1>This is actual message embedded in HTML tags</h1>", "text/html");
Transport 개체를 사용하여 메시지를 보냅니다.
자바 클래스 생성
자바 클래스 파일 만들기 SendHTMLEmail, 그 내용은 다음과 같습니다.
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);
}
}
}
호스트 공급자 JangoSMTP에서 제공하는 SMTP 서버를 사용하고 있으므로 사용자 이름과 비밀번호를 인증해야합니다. javax.mail.PasswordAuthentication의 클래스는 암호를 인증하는 데 사용됩니다.
컴파일 및 실행
이제 클래스가 준비되었으므로 위의 클래스를 컴파일 해 보겠습니다. 클래스 SendHTMLEmail.java를 디렉토리에 저장했습니다./home/manisha/JavaMailAPIExercise. 클래스 경로에 jars javax.mail.jar 및 activation.jar 이 필요합니다 . 아래 명령을 실행하여 명령 프롬프트에서 클래스를 컴파일하십시오 (두 jar 모두 / home / manisha / 디렉토리에 있음).
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendHTMLEmail.java
이제 클래스가 컴파일되었으므로 아래 명령을 실행하여 실행하십시오.
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendHTMLEmail
출력 확인
명령 콘솔에 다음 메시지가 표시되어야합니다.
Sent message successfully....
JangoSMTP를 통해 내 Gmail 주소로 이메일을 보낼 때 다음 메일이 내 Gmail 계정받은 편지함으로 수신됩니다.
다음은 인라인 이미지를 사용하여 컴퓨터에서 HTML 이메일을 보내는 예입니다. 여기서는 이메일이 목적지 이메일 주소로 전송되는 JangoSMTP 서버를 사용했습니다. 설정은 환경 설정 장 에서 설명합니다 .
인라인 이미지와 함께 이메일을 보내려면 다음 단계를 따르세요.
세션 받기
기본 MimeMessage 개체를 만들고 메시지에서 From, To, Subject 를 설정 합니다.
MimeMultipart 객체를 만듭니다.
이 예에서는 이메일에 HTML 부분과 이미지가 있습니다. 따라서 먼저 HTML 콘텐츠를 만들고 multipart 개체에 다음과 같이 설정합니다.
// 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);
다음으로 다음과 같이 Datahandler를 만들어 이미지를 추가합니다.
// 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>");
다음으로 메시지에서 멀티 파트를 다음과 같이 설정합니다.
message.setContent(multipart);
Transport 개체를 사용하여 메시지를 보냅니다.
자바 클래스 생성
자바 클래스 파일 만들기 SendInlineImagesInEmail, 그 내용은 다음과 같습니다.
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);
}
}
}
호스트 공급자 JangoSMTP에서 제공하는 SMTP 서버를 사용하고 있으므로 사용자 이름과 비밀번호를 인증해야합니다. javax.mail.PasswordAuthentication의 클래스는 암호를 인증하는 데 사용됩니다.
컴파일 및 실행
이제 클래스가 준비되었으므로 위의 클래스를 컴파일 해 보겠습니다. SendInlineImagesInEmail.java 클래스를 디렉토리에 저장했습니다./home/manisha/JavaMailAPIExercise. 클래스 경로에 jars javax.mail.jar 및 activation.jar 이 필요합니다 . 아래 명령을 실행하여 명령 프롬프트에서 클래스를 컴파일하십시오 (두 jar 모두 / home / manisha / 디렉토리에 있음).
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendInlineImagesInEmail.java
이제 클래스가 컴파일되었으므로 아래 명령을 실행하여 실행하십시오.
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendInlineImagesInEmail
출력 확인
명령 콘솔에 다음 메시지가 표시되어야합니다.
Sent message successfully....
JangoSMTP를 통해 내 Gmail 주소로 이메일을 보낼 때 다음 메일이 내 Gmail 계정받은 편지함으로 수신됩니다.
이 장을 진행하기 전에 이해해야 할 두 가지 측면이 있습니다. 그들은Check 과 Fetch.
CheckJavaMail에서 이메일을 보내는 것은 메일 함의 각 폴더를 열고 각 메시지를 가져 오는 프로세스입니다. 여기서는 각 메시지의 헤더, 즉 From, To, 제목 만 확인합니다 . 내용을 읽지 않습니다.
FetchJavaMail에서 이메일을 보내는 것은 메일 함의 각 폴더를 열고 각 메시지를 가져 오는 프로세스입니다. 헤더와 함께 콘텐츠 유형을 인식하여 콘텐츠를 읽습니다.
JavaMail API를 사용하여 이메일을 확인하거나 가져 오려면 POP 또는 IMAP 서버가 필요합니다. 이메일을 확인하고 가져 오려면 Folder 및 Store 클래스가 필요합니다. 여기서는 GMAIL의 POP3 서버 (pop.gmail.com)를 사용했습니다. 이 장에서는 JavaMail API를 사용하여 이메일을 확인하는 방법에 대해 설명합니다. 가져 오기는 다음 장에서 다룹니다. 이메일을 확인하려면 :
세션 받기
pop3 Store 객체를 생성하고 POP 서버와 연결합니다.
폴더 개체를 만듭니다. 사서함에서 적절한 폴더를 엽니 다.
메시지를 받으십시오.
저장소 및 폴더 개체를 닫습니다.
자바 클래스 생성
자바 클래스 파일 만들기 CheckingMails, 그 내용은 다음과 같습니다.
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);
}
}
컴파일 및 실행
이제 클래스가 준비되었으므로 위의 클래스를 컴파일 해 보겠습니다. CheckingMails.java 클래스를 디렉토리에 저장했습니다./home/manisha/JavaMailAPIExercise. 클래스 경로에 jars javax.mail.jar 및 activation.jar 이 필요합니다 . 아래 명령을 실행하여 명령 프롬프트에서 클래스를 컴파일하십시오 (두 jar 모두 / home / manisha / 디렉토리에 있음).
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: CheckingMails.java
이제 클래스가 컴파일되었으므로 아래 명령을 실행하여 실행하십시오.
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: CheckingMails
출력 확인
명령 콘솔에 다음 메시지가 표시되어야합니다.
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@2d1e165f
여기서는받은 편지함에 4 개의 메시지 수를 인쇄했습니다. 또한 각 이메일 메시지에 대해 제목, 보낸 사람 주소 및 텍스트를 인쇄했습니다.
이전 장에서 우리는 이메일을 확인하는 방법을 배웠습니다. 이제 각 이메일을 가져오고 내용을 읽는 방법을 살펴 보겠습니다. 자바 클래스를 작성하자FetchingEmail 다음 유형의 이메일을 읽습니다.
간단한 이메일
첨부 파일이있는 이메일
인라인 이미지가있는 이메일
코드에서 따르는 기본 단계는 다음과 같습니다.
Session 개체를 가져옵니다.
POP3 저장소 개체를 만들고 저장소에 연결합니다.
폴더 개체를 만들고 사서함에서 적절한 폴더를 엽니 다.
메시지를 검색합니다.
폴더를 닫고 개체를 각각 저장합니다.
자바 클래스 생성
자바 클래스 파일 만들기 FetchingEmail, 그 내용은 다음과 같습니다.
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());
}
}
emailSession.setDebug (true); 명령문의 주석 처리를 제거하여 디버그를 설정할 수 있습니다 .
컴파일 및 실행
이제 클래스가 준비되었으므로 위의 클래스를 컴파일 해 보겠습니다. FetchingEmail.java 클래스를 디렉토리에 저장했습니다./home/manisha/JavaMailAPIExercise. 클래스 경로에 jars javax.mail.jar 및 activation.jar 이 필요합니다 . 아래 명령을 실행하여 명령 프롬프트에서 클래스를 컴파일하십시오 (두 jar 모두 / home / manisha / 디렉토리에 있음).
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: FetchingEmail.java
이제 클래스가 컴파일되었으므로 아래 명령을 실행하여 실행하십시오.
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: FetchingEmail
출력 확인
명령 콘솔에 다음 메시지가 표시되어야합니다.
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"
여기에서 사서함에 세 개의 이메일이 있음을 알 수 있습니다. 먼저 "Hi am a simple message string ...."메시지가있는 간단한 메일입니다. 두 번째 메일에는 첨부 파일이 있습니다. 첨부 파일의 내용도 위와 같이 인쇄됩니다. 세 번째 메일에는 인라인 이미지가 있습니다.
Checking Emails 장에서 CheckingMails.java를 수정 합니다 . 그 내용은 다음과 같습니다.
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);
}
}
emailSession.setDebug (true); 명령문의 주석 처리를 제거하여 디버그를 설정할 수 있습니다 .
컴파일 및 실행
이제 클래스가 준비되었으므로 위의 클래스를 컴파일 해 보겠습니다. CheckingMails.java 클래스를 디렉토리에 저장했습니다./home/manisha/JavaMailAPIExercise. 클래스 경로에 jars javax.mail.jar 및 activation.jar 이 필요합니다 . 아래 명령을 실행하여 명령 프롬프트에서 클래스를 컴파일하십시오 (두 jar 모두 / home / manisha / 디렉토리에 있음).
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: CheckingMails.java
이제 클래스가 컴파일되었으므로 아래 명령을 실행하여 실행하십시오.
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: CheckingMails
출력 확인
명령 콘솔에서 아래와 유사한 메시지를 볼 수 있습니다.
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@3ad5ba3a
이 장에서는 JavaMail API를 사용하여 이메일에 답장하는 방법을 살펴 봅니다. 아래 프로그램에서 따르는 기본 단계는 다음과 같습니다.
속성에서 POP 및 SMTP 서버 세부 정보가있는 세션 개체를 가져옵니다. 메시지를 검색하려면 POP 세부 정보가 필요하고 메시지를 보내려면 SMTP 세부 정보가 필요합니다.
POP3 저장소 개체를 만들고 저장소에 연결합니다.
폴더 개체를 만들고 사서함에서 적절한 폴더를 엽니 다.
메시지를 검색합니다.
메시지를 반복하고 회신하려면 "Y"또는 "y"를 입력합니다.
메시지의 모든 정보 (To, From, Subject, Content)를 가져옵니다.
Message.reply () 메서드를 사용하여 응답 메시지를 작성합니다. 이 방법은 적절한 수신자와 제목으로 새 메시지를 구성합니다. 이 메서드는 보낸 사람에게만 응답할지 (false) 아니면 모두에게 응답할지 (true)를 나타내는 부울 매개 변수를 사용합니다.
메시지에 From, Text 및 Reply-to를 설정하고 Transport 개체의 인스턴스를 통해 보냅니다.
전송, 폴더 및 저장소 개체를 각각 닫습니다.
여기서는 이메일이 목적지 이메일 주소로 전송되는 JangoSMTP 서버를 사용했습니다. 설정은 환경 설정 장 에서 설명합니다 .
자바 클래스 생성
자바 클래스 파일 만들기 ReplyToEmail, 그 내용은 다음과 같습니다.
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();
}
}
}
session.setDebug (true); 문을 주석 해제하여 디버그를 설정할 수 있습니다 .
컴파일 및 실행
이제 클래스가 준비되었으므로 위의 클래스를 컴파일 해 보겠습니다. ReplyToEmail.java 클래스를 디렉토리에 저장했습니다./home/manisha/JavaMailAPIExercise. 클래스 경로에 jars javax.mail.jar 및 activation.jar 이 필요합니다 . 아래 명령을 실행하여 명령 프롬프트에서 클래스를 컴파일하십시오 (두 jar 모두 / home / manisha / 디렉토리에 있음).
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: ReplyToEmail.java
이제 클래스가 컴파일되었으므로 다음 명령을 실행하여 실행하십시오.
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: ReplyToEmail
출력 확인
명령 콘솔에 다음 메시지가 표시되어야합니다.
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 ....
메일이 전송 된받은 편지함을 확인하십시오. 우리의 경우 수신 된 메시지는 다음과 같습니다.
이 장에서는 JavaMail API를 사용하여 이메일을 전달하는 방법을 살펴 봅니다. 아래 프로그램에서 따르는 기본 단계는 다음과 같습니다.
속성에서 POP 및 SMTP 서버 세부 정보가있는 세션 개체를 가져옵니다. 메시지를 검색하려면 POP 세부 정보가 필요하고 메시지를 보내려면 SMTP 세부 정보가 필요합니다.
POP3 저장소 개체를 만들고 저장소에 연결합니다.
폴더 개체를 만들고 사서함에서 적절한 폴더를 엽니 다.
메시지를 검색합니다.
메시지를 반복하고 전달하려면 "Y"또는 "y"를 입력합니다.
메시지의 모든 정보 (To, From, Subject, Content)를 가져옵니다.
메시지를 구성하는 부분으로 작업하여 전달 메시지를 작성하십시오. 첫 번째 부분은 메시지 텍스트이고 두 번째 부분은 전달할 메시지입니다. 둘을 여러 부분으로 결합하십시오. 그런 다음 올바른 주소가 지정된 메시지에 멀티 파트를 추가하고 보냅니다.
전송, 폴더 및 저장소 개체를 각각 닫습니다.
여기서는 이메일이 목적지 이메일 주소로 전송되는 JangoSMTP 서버를 사용했습니다. 설정은 환경 설정 장 에서 설명합니다 .
자바 클래스 생성
자바 클래스 파일 만들기 ForwardEmail, 그 내용은 다음과 같습니다.
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();
}
}
}
session.setDebug (true); 문을 주석 해제하여 디버그를 설정할 수 있습니다 .
컴파일 및 실행
이제 클래스가 준비되었으므로 위의 클래스를 컴파일 해 보겠습니다. ForwardEmail.java 클래스를 디렉토리에 저장했습니다./home/manisha/JavaMailAPIExercise. 클래스 경로에 jars javax.mail.jar 및 activation.jar 이 필요합니다 . 아래 명령을 실행하여 명령 프롬프트에서 클래스를 컴파일하십시오 (두 jar 모두 / home / manisha / 디렉토리에 있음).
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: ForwardEmail.java
이제 클래스가 컴파일되었으므로 다음 명령을 실행하여 실행하십시오.
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: ForwardEmail
출력 확인
명령 콘솔에 다음 메시지가 표시되어야합니다.
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....
메일이 전송 된받은 편지함을 확인하십시오. 우리의 경우 전달 된 메시지는 다음과 같습니다.
이 장에서는 JavaMail API를 사용하여 이메일을 삭제하는 방법을 살펴 봅니다. 메시지 삭제에는 메시지와 관련된 플래그 작업이 포함됩니다. 다른 상태, 일부 시스템 정의 및 일부 사용자 정의에 대해 다른 플래그가 있습니다. 미리 정의 된 플래그는 내부 클래스 Flags.Flag에 정의되어 있으며 다음과 같습니다.
Flags.Flag.ANSWERED
Flags.Flag.DELETED
Flags.Flag.DRAFT
Flags.Flag.FLAGGED
Flags.Flag.RECENT
Flags.Flag.SEEN
Flags.Flag.USER
POP 프로토콜은 메시지 삭제 만 지원합니다.
삭제 프로그램에서 따르는 기본 단계는 다음과 같습니다.
속성에서 POP 및 SMTP 서버 세부 정보가있는 세션 개체를 가져옵니다. 메시지를 검색하려면 POP 세부 정보가 필요하고 메시지를 보내려면 SMTP 세부 정보가 필요합니다.
POP3 저장소 개체를 만들고 저장소에 연결합니다.
폴더 개체를 만들고 READ_WRITE 모드로 사서함에서 적절한 폴더를 엽니 다.
받은 편지함 폴더에서 메시지를 검색합니다.
메시지를 반복하고 Message 객체에 대해 setFlag (Flags.Flag.DELETED, true) 메서드를 호출하여 메시지를 삭제하려면 "Y"또는 "y"를 입력합니다.
DELETED로 표시된 메시지는 Folder 개체에서 expunge () 메서드를 호출하거나 expunge가 true로 설정된 폴더를 닫을 때까지 실제로 삭제되지 않습니다.
저장소 개체를 닫습니다.
자바 클래스 생성
자바 클래스 파일 만들기 ForwardEmail, 그 내용은 다음과 같습니다.
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);
}
}
emailSession.setDebug (true); 명령문의 주석 처리를 제거하여 디버그를 설정할 수 있습니다 .
컴파일 및 실행
이제 클래스가 준비되었으므로 위의 클래스를 컴파일 해 보겠습니다. 클래스 DeleteEmail.java를 디렉토리에 저장했습니다./home/manisha/JavaMailAPIExercise. 클래스 경로에 jars javax.mail.jar 및 activation.jar 이 필요합니다 . 아래 명령을 실행하여 명령 프롬프트에서 클래스를 컴파일하십시오 (두 jar 모두 / home / manisha / 디렉토리에 있음).
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: DeleteEmail.java
이제 클래스가 컴파일되었으므로 다음 명령을 실행하여 실행하십시오.
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: DeleteEmail
출력 확인
명령 콘솔에 다음 메시지가 표시되어야합니다.
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: Testing
이전의 모든 장에서 우리는 JangoSMTP 서버를 사용하여 이메일을 보냈습니다. 이 장에서는 Gmail에서 제공하는 SMTP 서버에 대해 알아 봅니다. Gmail (특히)에서는 공용 SMTP 서버를 무료로 사용할 수 있습니다.
Gmail SMTP 서버 세부 정보는 여기 에서 찾을 수 있습니다 . 세부 정보에서 볼 수 있듯이 TLS 또는 SSL 연결을 사용하여 Gmail SMTP 서버를 통해 이메일을 보낼 수 있습니다.
Gmail SMTP 서버를 사용하여 이메일을 보내는 절차 는 호스트 서버를 변경한다는 점을 제외하고는 이메일 보내기 장에 설명 된 것과 유사 합니다. 전제 조건으로 발신자 이메일 주소는 활성 Gmail 계정이어야합니다. 예를 들어 보겠습니다.
자바 클래스 생성
Java 파일 만들기 SendEmailUsingGMailSMTP, 그 내용은 다음과 같습니다.
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);
}
}
}
여기서 호스트는 smtp.gmail.com 으로 설정되고 포트는 587 로 설정됩니다 . 여기에서 TLS 연결을 활성화했습니다.
컴파일 및 실행
이제 클래스가 준비되었으므로 위의 클래스를 컴파일 해 보겠습니다. 클래스 SendEmailUsingGMailSMTP.java를 디렉토리에 저장했습니다./home/manisha/JavaMailAPIExercise. 클래스 경로에 jars javax.mail.jar 및 activation.jar 이 필요합니다 . 아래 명령을 실행하여 명령 프롬프트에서 클래스를 컴파일하십시오 (두 jar 모두 / home / manisha / 디렉토리에 있음).
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmailUsingGMailSMTP.java
이제 클래스가 컴파일되었으므로 아래 명령을 실행하여 실행하십시오.
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmailUsingGMailSMTP
출력 확인
명령 콘솔에 다음 메시지가 표시되어야합니다.
Sent message successfully....
지금까지 우리는 주로 INBOX 폴더를 사용하여 이전 장에서 작업했습니다. 대부분의 메일이있는 기본 폴더입니다. 일부 시스템은이를 INBOX라고 부르고 다른 시스템은 다른 이름으로 부르기도합니다. 그러나 INBOX라는 이름을 사용하여 JavaMail API에서 언제든지 액세스 할 수 있습니다.
JavaMail API는 폴더를 추상 Folder 클래스의 인스턴스로 나타냅니다.
public abstract class Folder extends Object
이 클래스는 서버에서 명명 된 폴더를 요청하고, 폴더에서 메시지를 삭제하고, 폴더에서 특정 메시지를 검색하고, 폴더에 메시지를 나열하는 등의 방법을 선언합니다.
폴더 열기
Folder 클래스 의 유일한 생성자 가 protected 이므로 직접 폴더를 만들 수 없습니다 . 다음에서 폴더 를 가져올 수 있습니다 .
세션
가게
또는 다른 폴더
위의 모든 클래스에는 유사한 서명이있는 유사한 getFolder () 메서드가 있습니다.
public abstract Folder getFolder(String name) throws MessagingException
폴더 개체 를 가져 오는 데 도움이되는 몇 가지 방법 은 다음과 같습니다.
방법 | 기술 |
---|---|
부울 존재 () | 폴더가 실제로 존재하는지 확인합니다. Folder 개체를 가져 오기 전에이 방법을 사용하십시오. |
추상 무효 열기 (int 모드) | Folder를 받으면 닫힙니다. 이 방법을 사용하여 엽니 다. mode 는 Folder.READ_ONLY 또는 Folder.READ_WRITE 일 수 있습니다. |
추상 부울 isOpen () | 이 메서드는 폴더가 열려 있으면 true를 반환하고 닫혀 있으면 false를 반환합니다. |
추상 무효 닫기 (부울 정리) | 폴더를 닫습니다. 경우 영구 삭제의 인수가 사실 폴더에서 삭제 된 메시지는 서버의 실제 파일에서 삭제됩니다. 그렇지 않으면 단순히 삭제 된 것으로 표시 되지만 메시지는 여전히 삭제 취소 할 수 있습니다. |
기본 폴더 정보
다음은 폴더에 대한 기본 정보를 반환하는 Folder 클래스의 몇 가지 메서드입니다.
방법 | 기술 |
---|---|
추상 문자열 getName () | "TutorialsPoint Mail"과 같은 폴더 이름을 반환합니다. |
추상 문자열 getFullName () | "books / Manisha / TutorialsPoint Mail"과 같은 루트에서 전체 계층 이름을 반환합니다. |
URLName getURLName () | 이 폴더를 나타내는 URLName을 반환합니다. |
추상 폴더 getParent () | 이 폴더를 포함하는 폴더, 즉 상위 폴더의 이름을 반환합니다. 예 : 이전 "TutorialsPoint Mail"예제의 "Manisha". |
추상 int getType () | 폴더에 메시지 및 / 또는 다른 폴더가 포함될 수 있는지 여부를 나타내는 int를 반환합니다. |
int getMode () | 모드를 알 수없는 경우 두 개의 명명 된 상수 Folder.READ_ONLY 또는 Folder.READ_WRITE 또는 -1 중 하나를 반환합니다. |
getStore () 저장 | 이 폴더를 검색 한 저장소 개체를 반환합니다. |
추상 문자 getSeparator () | 이 폴더의 경로 이름을 직계 하위 폴더의 이름과 구분하는 구분 문자를 반환합니다. |
폴더 관리
다음은 폴더 관리에 도움이되는 몇 가지 방법입니다.
방법 | 기술 |
---|---|
추상 부울 생성 (int 유형) | 이 폴더의 Store에 새 폴더가 생성됩니다. 어디 유형은 다음과 같습니다 Folder.HOLDS_MESSAGES 또는 Folder.HOLDS_FOLDERS. 폴더가 성공적으로 생성되면 true를 반환하고 그렇지 않으면 false를 반환합니다 . |
추상 부울 삭제 (부울 재귀) | 이렇게하면 폴더가 닫힌 경우에만 폴더가 삭제됩니다. 그렇지 않으면 IllegalStateException이 발생합니다 . 경우 같이 Recurse가 있다 사실 , 다음 하위 폴더가 삭제됩니다. |
추상 부울 renameTo (폴더 f) | 이 폴더의 이름이 변경됩니다. 이름을 바꾸려면 폴더를 닫아야합니다. 그렇지 않으면 IllegalStateException이 발생합니다. |
폴더에서 메시지 관리
다음은 폴더의 메시지를 관리하는 데 도움이되는 몇 가지 방법입니다.
방법 | 기술 |
---|---|
abstract void appendMessages (Message [] 메시지) | 이름에서 알 수 있듯이 배열의 메시지는이 폴더의 끝에 배치됩니다. |
void copyMessages (Message [] 메시지, 폴더 대상) | 이 폴더의 메시지를 인수로 지정된 폴더로 복사합니다. |
추상 메시지 [] 영구 삭제 () | 폴더에서 메시지를 삭제하려면 Flags.Flag.DELETED 플래그를 true로 설정하십시오. 폴더에서 삭제 된 메시지를 물리적으로 제거하려면이 메서드를 호출해야합니다. |
폴더 내용 나열
폴더에 포함 된 폴더를 나열하는 방법에는 네 가지가 있습니다.
방법 | 기술 |
---|---|
폴더 [] 목록 () | 이 폴더에 포함 된 폴더를 나열하는 배열을 반환합니다. |
폴더 [] 목록 구독 됨 () | 이 폴더에 포함 된 모든 구독 폴더를 나열하는 배열이 반환됩니다. |
추상 폴더 [] 목록 (문자열 패턴) | 이는 패턴을 지정할 수 있다는 점을 제외 하면 list () 메소드 와 유사합니다 . 패턴은 일치하는 폴더의 이름을 제공하는 문자열입니다. |
폴더 [] listSubscribed (문자열 패턴) | 이것은 패턴을 지정할 수 있다는 점을 제외 하면 listSubscribed () 메소드 와 유사합니다 . 패턴은 일치하는 폴더의 이름을 제공하는 문자열입니다. |
메일 확인
방법 | 기술 |
---|---|
추상 int getMessageCount () | 이 메서드는 열려 있거나 닫힌 폴더에서 호출 할 수 있습니다. 그러나 닫힌 폴더의 경우이 메서드는 정확한 메시지 수를 쉽게 사용할 수 없음을 나타 내기 위해 -1을 반환하거나 반환하지 않을 수 있습니다. |
추상 부울 hasNewMessages () | 마지막으로 열린 이후 새 메시지가 폴더에 추가 된 경우 true를 반환 합니다 . |
int getNewMessageCount () | RECENT 플래그가 설정된 폴더의 메시지를 확인하여 새 메시지 수를 반환합니다. |
int getUnreadMessageCount () | 열린 폴더 또는 닫힌 폴더에서 호출 할 수 있습니다. 그러나 닫힌 폴더의 경우 -1을 반환하여 실제 답변이 너무 비싸다는 것을 나타낼 수 있습니다. |
폴더에서 메시지 받기
Folder 클래스는 열린 폴더에서 메시지를 검색하는 네 가지 방법을 제공합니다.
방법 | 기술 |
---|---|
추상 메시지 getMessage (int messageNumber) | 폴더의 n 번째 메시지를 반환합니다. 폴더의 첫 번째 메시지는 1 번입니다. |
메시지 [] getMessages () | 이 폴더의 모든 메시지를 나타내는 Message 개체 의 배열을 반환 합니다. |
Message [] getMessages (int start, int end) | 이것은 폴더에서 시작으로 시작하여 끝으로 끝나는 메시지 객체 의 배열을 반환 합니다. |
Message [] getMessages (int [] messageNumbers) | 이는 messageNumbers 배열 에서 숫자로 특별히 식별 된 메시지 만 포함하는 배열을 반환합니다 . |
무효 가져 오기 (Message [] 메시지, FetchProfile fp) | 주어진 메시지에 대해 FetchProfile에 지정된 항목을 프리 페치합니다. FetchProfile 인수는 메시지에서 프리 페치 할 헤더를 지정합니다. |
폴더 검색
서버가 검색을 지원하는 경우 (많은 IMAP 서버가 지원하고 대부분의 POP 서버는 지원하지 않음) 특정 기준을 충족하는 메시지를 폴더에서 쉽게 검색 할 수 있습니다. 기준은 SearchTerm 객체로 인코딩됩니다. 다음은 두 가지 검색 방법입니다.
방법 | 기술 |
---|---|
메시지 [] 검색 ( 검색어 용어) | 이 폴더에서 지정된 검색 기준과 일치하는 메시지를 검색합니다. 일치하는 메시지를 포함하는 배열을 반환합니다. 일치하는 항목이 없으면 빈 배열을 반환합니다. |
메시지 [] 검색 (검색어, 메시지 [] 메시지) | 지정된 검색 기준과 일치하는 메시지에 대해 지정된 메시지 배열을 검색합니다. 일치하는 메시지를 포함하는 배열을 반환합니다. 일치하는 항목이 없으면 빈 배열을 반환합니다. 지정된 메시지 개체는이 폴더에 속해야합니다. |
플래그
플래그 수정은 폴더의 전체 메시지 집합에 대한 플래그를 변경해야 할 때 유용합니다. 다음은 Folder 클래스에서 제공되는 메서드입니다.
방법 | 기술 |
---|---|
void setFlags (Message [] 메시지, 플래그 플래그, 부울 값) | 배열에 지정된 메시지에 지정된 플래그를 설정합니다. |
void setFlags (int start, int end, Flags 플래그, 부울 값) | 시작부터 끝까지 번호가 매겨진 메시지에 지정된 플래그를 설정합니다. |
void setFlags (int [] messageNumbers, 플래그 플래그, 부울 값) | 메시지 번호가 배열에있는 메시지에 지정된 플래그를 설정합니다. |
추상 플래그 getPermanentFlags () | 이 폴더가 모든 메시지에 대해 지원하는 플래그를 반환합니다. |
JavaMail의 할당량은 전자 메일 저장소에있는 제한되거나 고정 된 메시지 수 또는 양입니다. 각 메일 서비스 요청은 JavaMail API 호출 할당량에 포함됩니다. 이메일 서비스는 다음 할당량 기준을 적용 할 수 있습니다.
첨부 파일을 포함하여 보내는 메일 메시지의 최대 크기입니다.
첨부 파일을 포함한 수신 메일 메시지의 최대 크기.
관리자가 수신자 인 경우 최대 메시지 크기
할당량 관리를 위해 JavaMail에는 다음 클래스가 있습니다.
수업 | 기술 |
---|---|
공개 클래스 할당량 | 이 클래스는 주어진 할당량 루트에 대한 할당량 집합을 나타냅니다. 각 할당량 루트에는 Quota.Resource 클래스로 표시되는 리소스 집합이 있습니다. 각 리소스에는 이름 (예 : "STORAGE"), 현재 사용량 및 사용량 제한이 있습니다. 여기에는 setResourceLimit (String name, long limit) 메서드가 하나만 있습니다. |
공용 정적 클래스 Quota.Resource | 할당량 루트의 개별 리소스를 나타냅니다. |
공용 인터페이스 QuotaAwareStore | 할당량을 지원하는 저장소에서 구현 한 인터페이스입니다. getQuota 및 setQuota 방법은 IMAP 할당량 확장에 의해 정의 된 할당량 모델을 지원합니다. GmailSSLStore, GmailStore, IMAPSSLStore, IMAPStore 는이 인터페이스의 알려진 구현 클래스입니다. |
다음 섹션에서 메일 저장소 이름, 제한 및 사용을 확인하는 예를 살펴 보겠습니다.
자바 클래스 생성
자바 클래스 파일 만들기 QuotaExample, 그 내용은 다음과 같습니다.
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();
}
}
}
IMAPStore는 QuotaAwareStore를 구현하므로 IMAP (imap.gmail.com) 서버를 통해 Gmail 서비스에 연결합니다. Store 객체를 얻으면 Quota 배열을 가져 와서 반복하고 관련 정보를 인쇄합니다.
컴파일 및 실행
이제 클래스가 준비되었으므로 위의 클래스를 컴파일 해 보겠습니다. QuotaExample.java 클래스를 디렉토리에 저장했습니다./home/manisha/JavaMailAPIExercise. 클래스 경로에 jars javax.mail.jar 및 activation.jar 이 필요합니다 . 아래 명령을 실행하여 명령 프롬프트에서 클래스를 컴파일하십시오 (두 jar 모두 / home / manisha / 디렉토리에 있음).
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: QuotaExample.java
이제 클래스가 컴파일되었으므로 아래 명령을 실행하여 실행하십시오.
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: QuotaExample
출력 확인
명령 콘솔에 유사한 메시지가 표시되어야합니다.
imapStore ---imaps://abc%[email protected]
quotaRoot:''
name:'STORAGE', limit:'15728640', usage:'513'
메시지는 여러 가지 이유로 반송 될 수 있습니다. 이 문제는 rfc1211 에서 자세히 설명 합니다. 서버 만 특정 사서함 또는 사용자 이름의 존재를 확인할 수 있습니다. 서버가 오류를 감지하면 원본 메시지를 보낸 사람에게 실패 이유를 나타내는 메시지를 반환합니다.
배달 상태 알림을 다루는 많은 인터넷 표준이 있지만 많은 서버가 이러한 새로운 표준을 지원하지 않고 대신 이러한 오류 메시지를 반환하는 임시 기술을 사용합니다. 따라서 반송 된 메시지를 문제를 일으킨 원본 메시지와 연관시키는 것은 매우 어렵습니다 .
JavaMail은 전달 상태 알림 구문 분석을 지원합니다. 이 문제를 처리하기위한 많은 기술과 경험적 방법이 있습니다. 기술 중 하나는 Variable Envelope Return Paths입니다. 아래 예와 같이 enveloper에서 반환 경로를 설정할 수 있습니다. 반송 메일이 전송되는 주소입니다. 이 주소를 From : 헤더와 다른 일반 주소로 설정하여 원격 반송을 처리 할 수 있습니다. JavaMail에서 mail.smtp.from 속성 을 설정하면됩니다 .
자바 클래스 생성
자바 클래스 파일 만들기 SendEmail, 그 내용은 다음과 같습니다.
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()
}
여기에서 우리는 재산 것을 볼 수 있습니다 mail.smtp.from가 으로부터 다른 설정 에서 주소를 입력합니다.
컴파일 및 실행
이제 클래스가 준비되었으므로 위의 클래스를 컴파일 해 보겠습니다. 클래스 SendEmail.java를 디렉토리에 저장했습니다./home/manisha/JavaMailAPIExercise. 클래스 경로에 jars javax.mail.jar 및 activation.jar 이 필요합니다 . 아래 명령을 실행하여 명령 프롬프트에서 클래스를 컴파일하십시오 (두 jar 모두 / home / manisha / 디렉토리에 있음).
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmail.java
이제 클래스가 컴파일되었으므로 아래 명령을 실행하여 실행하십시오.
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmail
출력 확인
명령 콘솔에 다음 메시지가 표시되어야합니다.
Sending ....
Sending done ...
SMTP는 Simple Mail Transfer Protocol. 인터넷 프로토콜 (IP) 네트워크를 통한 전자 메일 (이메일) 전송을위한 인터넷 표준입니다. SMTP는 TCP 포트 25를 사용합니다. SMTPS는 그 자체로 프로토콜이 아니지만 SSL로 보호되는 SMTP 연결은 축약 형 SMTPS로 알려져 있습니다.
JavaMail API에 패키지가 있습니다. com.sun.mail.smtpSMTP 서버에 액세스하기위한 SMTP 프로토콜 공급자 역할을합니다. 다음 표에는이 패키지에 포함 된 클래스가 나열되어 있습니다.
수업 | 기술 |
---|---|
SMTPMessage | 이 클래스는이 메시지가 SMTP를 통해 전송 될 때 사용될 다양한 SMTP 옵션과 매개 변수를 지정할 수있는 MimeMessage 클래스의 전문화입니다. |
SMTPSSLTransport | 이 클래스는 메시지 전송 및 전송을 위해 SSL을 통한 SMTP를 사용하여 전송 추상 클래스를 구현합니다. |
SMTPTransport | 이 클래스는 메시지 전송 및 전송을 위해 SMTP를 사용하여 전송 추상 클래스를 구현합니다. |
다음 표에는 발생한 예외가 나열되어 있습니다.
예외 | 기술 |
---|---|
SMTPAddressFailedException | 이 예외는 메시지를 보낼 수 없을 때 발생합니다. |
SMTPAddressSucceededException | 이 예외는 mail.smtp.reportsuccess 속성이 true 일 때 SendFailedException과 연결됩니다 . |
SMTPSenderFailedException | 이 예외는 메시지를 보낼 수 없을 때 발생합니다. |
SMTPSendFailedException | 이 예외는 메시지를 보낼 수 없을 때 throw됩니다. 예외에는 메일 서버가 거부 한 보낸 사람의 주소가 포함됩니다. |
그만큼 com.sun.mail.smtp공급자는 선택적으로 SMTP 인증을 사용합니다. SMTP 인증을 사용하려면 mail.smtp.auth 속성 을 설정 하거나 SMTP 서버에 연결할 때 SMTP 전송에 사용자 이름과 암호를 제공해야합니다. 다음 접근 방식 중 하나를 사용하여이를 수행 할 수 있습니다.
메일 세션을 생성 할 때 Authenticator 개체를 제공하고 Authenticator 콜백 중에 사용자 이름과 비밀번호 정보를 제공합니다. 콜백에 대한 기본 사용자 이름을 제공하도록 mail.smtp.user 속성을 설정할 수 있지만 암호는 여전히 명시 적으로 제공해야합니다. 이 접근 방식을 사용하면 정적 전송 전송 방법을 사용하여 메시지를 보낼 수 있습니다. 예를 들면 :
Transport.send(message);
사용자 이름 및 암호 인수를 사용하여 명시 적으로 Transport connect 메서드를 호출합니다. 예를 들면 :
Transport tr = session.getTransport("smtp");
tr.connect(smtphost, username, password);
msg.saveChanges();
tr.sendMessage(msg, msg.getAllRecipients());
tr.close();
SMTP 프로토콜 공급자는 JavaMail 세션 개체에 설정할 수있는 다음 속성을 지원합니다. 속성은 항상 문자열로 설정됩니다. 예를 들면 :
props.put("mail.smtp.port", "587");
IMAP은 Internet Message Access Protocol. 전자 메일 클라이언트가 원격 메일 서버의 전자 메일에 액세스 할 수 있도록하는 응용 프로그램 계층 인터넷 프로토콜입니다. IMAP 서버는 일반적으로 잘 알려진 포트 143에서 수신합니다. IMAP (IMAPS)는 포트 번호 993에 할당됩니다.
IMAP는 온라인 및 오프라인 작동 모드를 모두 지원합니다. IMAP을 사용하는 전자 메일 클라이언트는 일반적으로 사용자가 명시 적으로 삭제할 때까지 서버에 메시지를 남겨 둡니다.
꾸러미 com.sun.mail.imapIMAP 메시지 저장소에 대한 액세스를 제공하는 JavaMail API 용 IMAP 프로토콜 공급자입니다. 아래 표에는이 공급자의 인터페이스와 클래스가 나열되어 있습니다.
클래스 / 인터페이스 | 기술 |
---|---|
IMAPFolder.ProtocolCommand | 이것은 사용자 정의 IMAP 프로토콜 명령을위한 간단한 인터페이스 입니다. |
ACL | 이것은 수업입니다. 특정 인증 식별자 (사용자 또는 그룹)에 대한 액세스 제어 목록 항목입니다. |
IMAPFolder | 이 클래스는 IMAP 폴더를 구현합니다. |
IMAPFolder.FetchProfileItem | 이것은 헤더를 가져 오는 클래스입니다. |
IMAPMessage | 이 클래스는 ReadableMime 객체를 구현합니다. |
IMAPMessage.FetchProfileCondition | 이 클래스는 폴더의 각 메시지에 대해 수행 할 테스트를 구현합니다. |
IMAPSSLStore | 이 클래스는 SSL을 통해 IMAP 메시지 저장소에 대한 액세스를 제공합니다. |
IMAPStore | 이 클래스는 IMAP 메시지 저장소에 대한 액세스를 제공합니다. |
진상 | 이 클래스는 인증 식별자 (예 : 사용자 또는 그룹)에 대한 권한 집합을 나타냅니다. |
권리. | 이 내부 클래스는 개인의 권리를 나타냅니다. |
SortTerm | RFC 5256에 정의 된 특정 정렬 기준. |
이 공급자 위에 주목해야 할 몇 가지 사항 :
이 공급자는 IMAP4 및 IMAP4rev1 프로토콜을 모두 지원합니다.
연결된 IMAPStore는 IMAP 서버와 통신하는 데 사용할 IMAP 프로토콜 개체 풀을 유지합니다. 폴더가 열리고 새 IMAP 프로토콜 개체가 필요하면 IMAPStore는 연결 풀에서 폴더를 제공하거나 사용할 수없는 경우 생성합니다. 폴더가 닫히면 해당 IMAP 프로토콜 개체가 연결 풀에 반환됩니다.
연결된 IMAPStore 개체는 저장소에 IMAP 서버에 대한 전용 연결을 제공하는 별도의 IMAP 프로토콜 개체를 유지하거나 유지하지 않을 수 있습니다.
POP (Post Office Protocol)은 로컬 전자 메일 클라이언트가 TCP / IP 연결을 통해 원격 서버에서 전자 메일을 검색하는 데 사용하는 응용 프로그램 계층 인터넷 표준 프로토콜입니다. POP는 원격 사서함에 액세스하기위한 간단한 다운로드 및 삭제 요구 사항을 지원합니다. POP3 서버는 잘 알려진 포트 110에서 수신 대기합니다.
꾸러미 com.sun.mail.pop3POP3 메시지 저장소에 대한 액세스를 제공하는 JavaMail API 용 POP3 프로토콜 공급자입니다. 아래 표에는이 패키지의 클래스가 나열되어 있습니다.
이름 | 기술 |
---|---|
POP3 폴더 | POP3 폴더 ( "INBOX"만 가능). |
POP3Message | POP3 메시지. |
POP3SSLStore | SSL을 사용하는 POP3 메시지 저장소. |
POP3Store | POP3 메시지 저장소. |
이 공급자 위에 주목해야 할 몇 가지 사항 :
POP3 공급자는 이름이 지정된 단일 폴더 만 지원합니다. INBOX. POP3 프로토콜의 제한으로 인해 이벤트 알림, 폴더 관리, 플래그 관리 등과 같은 많은 JavaMail API 기능이 허용되지 않습니다.
POP3 공급자는 프로토콜 이름 pop3 또는 pop3 : // user : password @ host : port / INBOX " 형식의 URL을 사용하여 JavaMail API를 통해 액세스됩니다 .
POP3는 영구 플래그를 지원하지 않습니다. 예를 들어, Flags.Flag.RECENT 플래그는 POP3 메시지에 대해 설정되지 않습니다. POP3 사서함의 어떤 메시지가 새 메시지인지 결정하는 것은 응용 프로그램에 달려 있습니다.
POP3는 Folder.expunge () 메서드를 지원하지 않습니다. 메시지를 삭제하고 정리하려면 메시지에 Flags.Flag.DELETED 플래그를 설정하고 Folder.close (true) 메서드를 사용하여 폴더를 닫습니다.
POP3는 수신 된 날짜를 제공하지 않으므로 getReceivedDate 메서드는 null을 반환합니다.
POP3 메시지의 헤더에 액세스하면 POP3 공급자는 TOP 명령을 사용하여 모든 헤더를 가져온 다음 캐시합니다.
POP3 메시지의 내용에 액세스하면 POP3 공급자는 RETR 명령을 사용하여 전체 메시지를 가져옵니다.
POP3Message.invalidate의 방법은 폴더를 닫지 않고 무효화 캐시 된 데이터를 사용할 수 있습니다.