Foros del web, para los que viven de bits

Hola:
Como puedo hacer un JSP para enviar un mail???Es que no tengo ni idea de Java....
Gracias

Hola , kamarada, necesitas tener un par de jar's, para utilizar el maiul de JSP (mail.jar y activation.jar, consulta la página web de sun).

import java.io.*;
import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.servlet.http.HttpSession;
import javax.activation.*;
import java.net.URL;

/* Clase creada para el envío de correo mediante protocolo SMTP */
public class MiMail {
/**
* Parsea las direcciones de correo desde una cadena con las direcciones separadas por comas.
* @param addresses Cadena con las direcciones de correo
* @return Vector con las direcciones parseadas.
*/
static Vector parseAddresses( String sAddresses)
{
Vector vector = new Vector();
if ( sAddresses != null) {
StringTokenizer st = new StringTokenizer( sAddresses, ",");
while ( st.hasMoreTokens()) { vector.add( st.nextToken()); }
}
return vector;
}

/**
* Parsea los attachments desde una cadena con los attachments separados por comas.
* @param attachments Cadena con los attachments de correo
* @return Vector con los attachments parseados.
*/
static Vector parseAttachments( String sAttachments){return parseAddresses( sAttachments);}

public MiMail(){ }
/**
* Envia un correo por SMTP.
* @param sFromAddress Dirección del remitente.
* @param sToAddress Cadena con los destinatarios separados por comas.
* @param sSubject Asunto del correo.
* @param sBody Texto del correo.
* @param sBodyHTML Correo en html.
* @param sFileAttachments Cadena con los attachments separados por comas..
*/
protected static void send( String sFromAddress, String sToAddresses,
String sSubject, String sBody, String sBodyHTML, String sFileAttachments)
throws AddressException, MessagingException {
// Set this variable to be your SMTP host
String mailHost = "cmmail";
String sFrom = sFromAddress;
Vector vTo = parseAddresses( sToAddresses);
Vector vAttachments = parseAttachments( sFileAttachments);


//Get system properties
Properties props = System.getProperties();

//Specify the desired SMTP server
props.put("mail.smtp.host", mailHost);

// create a new Session object
Session sesion = Session.getInstance(props, null);
//sesion.setDebug(true);

// create a new MimeMessage object (using the Session created above)
Message message = new MimeMessage(sesion);

// Message add FROM
message.setFrom(new InternetAddress(sFrom));

// Message add TO
//message.setRecipients(Message.RecipientType.TO, new InternetAddress[] { new InternetAddress(sTo) });
for ( Enumeration eToAddresses = vTo.elements(); eToAddresses.hasMoreElements();) {
message.addRecipient( Message.RecipientType.TO, new InternetAddress( (String) eToAddresses.nextElement()));
}
// Message add Subject
message.setSubject(sSubject);

if ( vAttachments.size() == 0) { // No Multi-part mail
message.setText(sBody);
}
else{
//Necesitamos crear el objeto Multipart:
//Multipart multipart = new MimeMultipart();
Multipart multipart = new MimeMultipart( ( sBodyHTML == null || sBodyHTML.length() == 0) ? "mixed" : "related");

// Para la parte uno, creamos un BodyPart y seleccionamos el texto para
// ser un mensaje. Luego añadimos el BodyPart al Multipart recién creado.
BodyPart messageBodyPart = new MimeBodyPart();
messageBodyPart.setText(sBody + "\n");
multipart.addBodyPart(messageBodyPart);

// Create part text, Fill sBodyHTML and add the part
if ( sBodyHTML != null ){//|| sBodyHTML.length() > 0) {
BodyPart messageHtmlTextPart = new MimeBodyPart();
messageHtmlTextPart.setDataHandler( new DataHandler( new SMTPByteArrayDataSource( sBodyHTML, "text/html")));
multipart.addBodyPart( messageHtmlTextPart);
}

// Create part attachments, Fill attachments and add the part
for ( Enumeration eAttachments = vAttachments.elements(); eAttachments.hasMoreElements();)
{
String nameFile = ( String) eAttachments.nextElement();
// Para la parte dos, necesitamos crear otro BodyPart, pero esta vez,
// necesitamos crear un DataSource para el fichero:
BodyPart messageAttachmentsPart = new MimeBodyPart();
DataSource source = new FileDataSource( nameFile);
// Usamos un objeto DataHandler para adjuntar los datos al mensaje.
// Simplemente creamos un DataHandler para la fuente y lo adjuntamos al
// mensaje:
messageAttachmentsPart.setDataHandler( new DataHandler(source));
// Debemos recordar seleccionar el nombre de fichero para el attachment.
// Esto permite al receptor conocer el nombre (y el tipo) del fichero
// recibido.
//messageAttachmentsPart.setHeader( "Content-ID", nameFile);

//messageAttachmentsPart.setFileName( ( new File( nameFile)).getName());
StringTokenizer ftokenizer = new StringTokenizer(nameFile,"\\/:");
String filename = ftokenizer.nextToken();
while(ftokenizer.hasMoreTokens()) filename = ftokenizer.nextToken();
messageAttachmentsPart.setFileName(filename);

//Adjuntamos la parte dos de la misma forma que la parte uno:
multipart.addBodyPart( messageAttachmentsPart);
}
// Para la parte dos, necesitamos crear otro BodyPart, pero esta vez,
// necesitamos crear un DataSource para el fichero:
//messageBodyPart = new MimeBodyPart();
//DataSource source = new FileDataSource(sFileAttachments);

// Usamos un objeto DataHandler para adjuntar los datos al mensaje.
// Simplemente creamos un DataHandler para la fuente y lo adjuntamos al
// mensaje:
//messageBodyPart.setDataHandler(new DataHandler(source));

// Debemos recordar seleccionar el nombre de fichero para el attachment.
// Esto permite al receptor conocer el nombre (y el tipo) del fichero
// recibido.
//messageBodyPart.setFileName(sAttachFile);
//messageBodyPart.setFileName("kk.txt");

//Adjuntamos la parte dos de la misma forma que la parte uno:
//multipart.addBodyPart(messageBodyPart);

// Y como paso final, antes de enviarlo, adjutamos el Multipart al Message:
message.setContent(multipart);
}
Transport.send(message);
// it worked!
}
/**
* Envia un correo por SMTP.
* @param host Dirección del host SMTP.
* @param sFromAddress Dirección del remitente.
* @param sToAddress Cadena con los destinatarios separados por comas.
* @param sSubject Asunto del correo.
* @param sBody Texto del correo.
*/
public static void sendMail( String sFromAddress,
String sToAddresses, String sSubject, String sBody) throws
AddressException, MessagingException {
send( sFromAddress, sToAddresses, sSubject, sBody, null, null);
}

/**
* Envia un correo por SMTP.
* @param sFromAddress Dirección del remitente.
* @param sToAddress Cadena con los destinatarios separados por comas.
* @param sSubject Asunto del correo.
* @param sBody Texto del correo.
* @param sFileAttachments Cadena con los attachments separados por comas..
*/
public static void sendMail( String sFromAddress,
String sToAddresses, String sSubject, String sBody, String sFileAttachments)
throws AddressException, MessagingException {
send( sFromAddress, sToAddresses, sSubject, sBody, null, sFileAttachments);
}

/**
* Envia un correo por SMTP.
* @param sFromAddress Dirección del remitente.
* @param sToAddress Cadena con los destinatarios separados por comas.
* @param sSubject Asunto del correo.
* @param sBody Texto del correo.
* @param sBodyHTML Correo en html.
* @param sFileAttachments Cadena con los attachments separados por comas..
*/
public static void sendMail( String sFromAddress,
String sToAddresses, String sSubject, String sBody, String sBodyHTML, String sFileAttachments)
throws AddressException, MessagingException {
send( sFromAddress, sToAddresses, sSubject, sBody, sBodyHTML, sFileAttachments);
}
}

Y tambien esta otra clase... (Ver Siguiente correo)


A ver si te sirve de algo.

Aqui va el resto, kolega , de la vega.

import java.util.*;
import java.io.*;
import javax.activation.*;

/** DataSource para cualquier texto plano. */
public class SMTPByteArrayDataSource implements DataSource {

private byte[] data;
private String type;

SMTPByteArrayDataSource( InputStream is, String type) {
this.type = type;
try {
ByteArrayOutputStream os = new ByteArrayOutputStream();
int ch;
while ( ( ch = is.read()) != -1) { os.write(ch);}
data = os.toByteArray();
} catch (IOException ioex){}
}

SMTPByteArrayDataSource( byte[] data, String type) {
this.data = data;
this.type = type;
}

SMTPByteArrayDataSource( String data, String type) {
this.data = data.getBytes();
this.type = type;
}

public InputStream getInputStream() throws IOException
{
if ( data == null) { throw new IOException( "No hay datos");}
return new ByteArrayInputStream( data);
}

public OutputStream getOutputStream() throws IOException {
throw new IOException( "No esta implementado");
}
public String getContentType() { return type;}
public String getName() {return "dummy";}
}

Gracias lo voy a probar