发电子邮件一定要用Javamail才能发吗?

两个文件。1. SMTPBean.java
import java.io.*;
import java.net.*;
import java.util.Date;/**
* This bean provides a simple, easy-to-use SMTP interface for use
* in sending standard emails (without attachments) from Java applets.
*
* The entire process of sending an email can be completed with just
* a few lines of code within a single try/catch block.
*
* There are several ways to utilize the SMTPBean.
* This first method does the whole email transmission with one line
* of code. After the email is sent, the connection is closed. Additional
* emails must be sent with a new SMTPBean: 
* (All examples assume useage from an Applet.)
* <blockquote>
* try { 
*   new SMTPBean(getCodeBase().getHost(), 25, "[email protected]", "[email protected]", "Message Subject", "This is the actual message"); 
* } 
* catch(SMTPException ex) { 
*   ex.printStackTrace(); 
* } 
*</blockquote>
* This example creates an SMTPBean (initially connected and hailed) that
* sends multiple emails to the same recipient: 
* <blockquote>
* try { 
*   SMTPBean bean = new SMTPBean(getCodeBase().getHost(), 25, "[email protected]", "[email protected]"); 
*   bean.sendMessage("[email protected]", "[email protected]", "Subject for first message", "This is message one."); 
*   bean.sendMessage("[email protected]", "[email protected]", "Subject for second message", "This is message two."); 
*   bean.logout(); 
* } 
* catch(SMTPException ex) { 
*   ex.printStackTrace(); 
* } 
* </blockquote>
* This example creates an SMTPBean (initially connected) that performs multiple hail and sendMessage
* calls to send email to many different recipients using the same connection. 
* <blockquote>
* try { 
*   SMTPBean bean = new SMTPBean(getCodeBase().getHost(), 25); 
*   bean.hailAndSendMessage("[email protected]", "[email protected]", "Subject Header", "This is the message."); 
*   bean.hailAndSendMessage("[email protected]", "[email protected]", "Subject Header", "This is the message."); 
*   bean.logout();
* } 
* catch(SMTPException ex) { 
*   ex.printStackTrace(); 
* } 
* </blockquote>
* This method creates a new SMTPBean (not connected) that sends email to
* one or more users. 
* <blockquote>
* try {
*   SMTPBean smtp = new SMTPBean(); 
*   smtp.connect(getCodeBase().getHost(), 25); 
*   smtp.hail("[email protected]", "[email protected]"); 
*   smtp.sendMessage("[email protected]", "[email protected]", "Email Subject", "This is the message."); 
*   smtp.logout(); 
* } 
* catch(SMTPException e) { 
*   System.out.println(e.getMessage()); 
* } 
* </blockquote>
*
* @author Tommy E. Cole, Jr. Lamasoft
* @version 1.0 (3/31/99)
*/

public class SMTPBean implements Serializable{
/** The socket used to send email transmissions. */
private Socket smtp;
/** The input stream used to read server repsonses. */
private BufferedReader input;
/** The output stream used to send commands and data. */
private PrintStream output;
/** The host from which the mail is sent. */
private String host;
/**
* The last reply received from the server after command submission.
* Useful when receiving an SMTPException, to see the actual error
* error response from the server.
* 
* @see #getLastResponse() getLastResponse
*/
private String lastreply;

/**
* Creates an initially disconnected SMTPBean. Before email can be
* sent the {@link #connect(String, int) connect}, {@link #hail(String, String) hail}
* and {@link #sendMessage(String, String, String, String) sendMessage} methods must be successfully
* called, in that order.
*/
public SMTPBean() {
}

/**
* Creates a SMTPBean that attempts to establish the Socket connection
* to the SMTP server. Before email can be sent the {@link #hail(String, String) hail}
* and {@link #sendMessage(String, String, String, String) sendMessage} methods must be successfully
* called, in that order.
* 
* @parameter server The String representation of the SMTP server.
* From an applet, this will be the result of a Applet.getCodeBase().getHost() method call.
* @parameter port The port that connects to the SMTP Server. This is almost
* always 25.
* 
* @throws SMTPException If an error is received while connecting to the SMTP server.
*/
public SMTPBean(String server, int port) throws SMTPException {
host = server;
connect(server, port);
}

/**
* Creates a SMTPBean that attempts to establish the Socket connection
* to the SMTP server and sends the hailing commands HELP, MAIL and RCPT.
* To send a message call {@link #sendMessage(String, String, String, String) sendMessage}.
* 
* @parameter server The String representation of the SMTP server.
* From an applet this will be the result of a call to Applet.getCodeBase().getHost().
* @parameter port The port that connects to the SMTP stream. This is usually 25.
* @parameter mailfrom The email address of the sender.
* @parameter mailto The email address of the intended recipient.
* 
* @throws SMTPException If an error code is received from the Server anytime
* during the connection and hailing phases.
*/
public SMTPBean(String server, int port, String mailfrom, String mailto) throws SMTPException{
host = server;
connect(server, port);
hail(mailfrom, mailto);
}

/**
* Creates a SMTPBean that attempts to establish the Socket connection
* to the SMTP server, sends the hailing commands HELP, MAIL and RCPT
* and sends the message all in one step.
* NOTE: This constructor assumes that only one message is to be sent and
* closes the Socket connection once the message is transmitted by making
* a call to {@link #logout() logout}. This is
* the only constructor of SMTPBean that performs this method call.
* 
* @parameter server The String representation of the SMTP server.
* From an applet this will be the result of a call to Applet.getCodeBase().getHost().
* @parameter port The port that connects to the SMTP stream. This is usually 25.
* @parameter mailfrom The email address of the sender.
* @parameter mailto The email address of the intended recipient.
* @paremeter subject The subject header for the email message.
* @parameter message The email message to send.
* 
* @throws SMTPException If an error code is received from the Server anytime
* during the connection, hailing or mail transmission phases.
*/
public SMTPBean(String server, int port, String mailfrom, String mailto, String subject, String message) throws SMTPException{
host = server;
connect(server, port);
hail(mailfrom, mailto);
sendMessage(mailfrom, mailto, subject, message);
logout();
}

/**
* This method establishes the header portion of the SMTP transaction,
* sending the HELP, MAIL and RCPT commands.
*
* @parameter server java.lang.String that denotes the SMTP Server. From an applet this will almost
* always be the result of an Applet.getCodeBase().getHost() call.
*
* @parameter port int that denotes the SMTP port of the HTTP server. This is almost always 25.
*
* @throws SMTPException if an error code is returned by the SMTP server.
*/
public void connect(String server, int port) throws SMTPException {
try {
host = server;
smtp = new Socket(server, port);
input = new BufferedReader(new InputStreamReader(smtp.getInputStream()));
output = new PrintStream(smtp.getOutputStream());
lastreply = input.readLine();
if (lastreply.charAt(0) == '2' || lastreply.charAt(0) == '3') {
}
else {
throw new SMTPException("Error connecting to SMTP server " + server + " on port " + port);
}
}
catch(Exception e) {
throw new SMTPException(e.getMessage());
}
}

/**
* This method makes the necessary SMTP hailing calls to the SMTP server,
* including HELO, MAIL and RCPT. Upon a successful call to this method,
* only the {@link #sendMessage(String, String, String, String) sendMessage} method is required
* to send mail.
* Before a call to this method can be made, a successful call to either
* {@link #connect(String, int) connect} or the SMTPBean(String, int)
* constructor.
* 
* @parameter mailfrom The email address of the sender.
* @parameter mailto The email address of the intended recipient.
* 
* @throws SMTPException If any error codes are returned during the hailing phase.
*/
public void hail(String mailfrom, String mailto) throws SMTPException {
if (! submitCommand("HELO " + host))
throw new SMTPException("Error occured during HELO command.");
if (! submitCommand("MAIL FROM: " + mailfrom))
throw new SMTPException("Error during MAIL command.");
if (! submitCommand("RCPT TO: " + mailto))
throw new SMTPException("Error during RCPT command.");
}

/**
* This method performs the actual email transmission function.
* Before a call to this method can be made, a successful call to
* {@link #connect(String, int) connect} and {@link #hail(String, String) hail}
* or the SMTPBean(String, int, String, String) constructor must be made.
* 
* @parameter mailfrom The email address of the sender.
* @parameter mailto The email address of the intended recipient.
* @parameter message The actual email message.
* 
* @throws SMTPException If an error message is received from the server
* during email transmission.
*/
public void sendMessage(String mailfrom, String mailto, String subject, String message) throws SMTPException {
if (! submitCommand("DATA"))
throw new SMTPException("Error during DATA command.");
String header = "From: " + mailfrom + "\r\n";
header += "To: " + mailto + "\r\n";
header += "Subject: " + subject + "\r\n";
header += "Date: " + (new Date()).toGMTString() + "\r\n\r\n";
if (! submitCommand(header + message + "\r\n."))
throw new SMTPException("Error during mail transmission.");
}

/**
* This method performs the {@link #hail(String, String) hail} and
* {@link #sendMessage(String, String, String, String) sendMessage} in one
* convenient method. This method is most useful when an SMTPBean
* is going to send multiple emails to different recipients.
* @parameter mailfrom The email address of the sender.
* @parameter mailto The email address of the intended recipient.
* @parameter subject The subject header for the email message.
* @parameter message The actual email message.
* @throws SMTPException If an error code is received from the SMTP server
* at any time during the hailing or transmission phases.
*/
public void hailAndSendMessage(String mailfrom, String mailto, String subject, String message) throws SMTPException {
hail(mailfrom, mailto);
sendMessage(mailfrom, mailto, subject, message);
}

/**
* A private method used to submit commands to the SMTP server.
* This method is called internally and should not be used
* directly.
*
* @return
* True or False where:
* True = An approved reponse was received after command submission.
* False = An unapproved reponse was received after command submission.
*
* @throws
* SMTPException.
*
* @see String#getLastResponse() getLastResponse
*/
private boolean submitCommand(String command) throws SMTPException {
try {
output.print(command + "\r\n");
lastreply = input.readLine();
if (lastreply.charAt(0) == '4' || lastreply.charAt(0) == '5')
return false;
else
return true;
}
catch(Exception e) {
throw new SMTPException(e.getMessage());
}
}

/**
* This method returns the last reponse received from the SMTP Server.
* This method is useful after receipt of an SMTPException, to view
* the server's actual rejected response.
*
* @return
* The last reponse from the SMTP Server.
*/
public String getLastResponse() {
return lastreply;
}

/**
* This method closes all existing data streams and sockets to the
* SMTP server. This method should be called by the SMTPBean once
* completed sending messages, unless the bean was created using the
* SMTPBean(String, int, String, String, String, String) constructor,
* since this construct performs the logout functions automatically.
*/
public void logout() throws SMTPException {
try {
if (! submitCommand("Quit"))
throw new SMTPException("Error during QUIT command");
input.close();
output.flush();
output.close();
smtp.close();
}
catch(Exception e) {
}
}
}
----------------------------------------------2. SMTPException.java/**
* A simple extension of the java.lang.Exception class designed
* to report all the possible exceptions during a typical
* SMTP session using the SMTPBean.
*/
public class SMTPException extends Exception {

/**
* Contains the message associated with this error
*/
private String message;

/**
* Creates a new SMTPException with the given message.
*/
public SMTPException(String message) {
this.message = message;
}

/**
* Returns the message associated with this exception.
*
* @return
* An instance of java.lang.String
*/
public String getMessage() {
return message;
}
}

调试易

发电子邮件一定要用Javamail才能发吗?

解决方案 »