Recibir correo electrónico

Los mensajes de correo electrónico se envían a tu app como solicitudes de HTTP. A fin de procesar los mensajes de correo electrónico entrantes, debes asociar las direcciones de correo electrónico con los servlets en la configuración de tu aplicación y, luego, incluir el código del servlet en tu app. El correo electrónico entrante genera solicitudes HTTP que se pasan a los servlets adecuados para su control.

Esta API es compatible con entornos de ejecución de primera generación y se puede usar en actualizaciones a los entornos de ejecución de segunda generación correspondientes. Si actualizas al entorno de ejecución de Java 11/17 de App Engine, consulta la guía de migración para obtener información acerca de tus opciones de migración para servicios agrupados en paquetes heredados.

Configura tu aplicación para recibir correos electrónicos

Cuando creas una aplicación nueva, el correo electrónico entrante está inhabilitado de manera predeterminada. Si no lo habilitas de forma explícita, se ignoran los mensajes de correo electrónico entrantes que se enviaron a la app.

Para habilitar el servicio de correo electrónico entrante, modifica los archivos de configuración appengine-web.xml y web.xml:

Habilita el correo electrónico en appengine-web.xml

Para modificar appengine-web.xml, agrega una sección inbound-services que habilite el servicio de correo electrónico entrante:

<inbound-services>
  <!-- Used to handle incoming mail. -->
  <service>mail</service>
  <!-- Used to handle bounced mail notifications. -->
  <service>mail_bounce</service>
</inbound-services>

Los mensajes de correo electrónico se envían a tu app como solicitudes HTTP POST mediante la siguiente URL:

/_ah/mail/<ADDRESS>

En el ejemplo anterior, <ADDRESS> es una dirección de correo electrónico completa que incluye el nombre de dominio. Ten en cuenta que, incluso si se implementa en un dominio personalizado, tu app no puede recibir correos electrónicos enviados a direcciones de ese dominio.

Habilita el correo electrónico en web.xml

Para modificar web.xml, mapea las URL de correo electrónico a servlets:

<servlet>
  <servlet-name>mailhandler</servlet-name>
  <servlet-class>com.example.appengine.mail.MailHandlerServlet</servlet-class>
</servlet>
<servlet-mapping>
  <servlet-name>mailhandler</servlet-name>
  <url-pattern>/_ah/mail/*</url-pattern>
</servlet-mapping>
<security-constraint>
  <web-resource-collection>
    <web-resource-name>mail</web-resource-name>
    <url-pattern>/_ah/mail/*</url-pattern>
  </web-resource-collection>
  <auth-constraint>
    <role-name>admin</role-name>
  </auth-constraint>
</security-constraint>

En los fragmentos anteriores, /_ah/mail/* coincide con todos los correos electrónicos dirigidos a la app. Los servlets de correo electrónico se ejecutan en la versión actual de la app en App Engine.

Envío de mensajes entrantes basado en patrones

Si tu aplicación utiliza la comparación de patrones, considera usar un enfoque basado en filtros en función de los siguientes fragmentos de código.

Controlador concreto

public class HandleDiscussionEmail extends MailHandlerBase {

  private static final Logger log = Logger.getLogger(HandleDiscussionEmail.class.getName());
  public HandleDiscussionEmail() { super("discuss-(.*)@(.*)"); }

  @Override
  protected boolean processMessage(HttpServletRequest req, HttpServletResponse res)
    throws ServletException
  {
    log.info("Received e-mail sent to discuss list.");
    MimeMessage msg = getMessageFromRequest(req);
    Matcher match = getMatcherFromRequest(req);
    // ...
    return true;
  }
}

El controlador concreto anterior se registra mediante el siguiente fragmento en web.xml:

<filter>
  <filter-name>HandleDiscussionEmail</filter-name>
  <filter-class>com.example.appengine.mail.HandleDiscussionEmail</filter-class>
</filter>
<filter-mapping>
  <filter-name>HandleDiscussionEmail</filter-name>
  <url-pattern>/_ah/mail/*</url-pattern>
</filter-mapping>

Ten en cuenta que no es posible agregar directivas security-constraint en los filtros; las políticas de seguridad del controlador deberán incorporarse de otra manera.

Controlador abstracto

public abstract class MailHandlerBase implements Filter {

  private Pattern pattern = null;

  protected MailHandlerBase(String pattern) {
    if (pattern == null || pattern.trim().length() == 0)
    {
      throw new IllegalArgumentException("Expected non-empty regular expression");
    }
    this.pattern = Pattern.compile("/_ah/mail/"+pattern);
  }

  @Override public void init(FilterConfig config) throws ServletException { }

  @Override public void destroy() { }

  /**
   * Process the message. A message will only be passed to this method
   * if the servletPath of the message (typically the recipient for
   * appengine) satisfies the pattern passed to the constructor. If
   * the implementation returns false, control is passed
   * to the next filter in the chain. If the implementation returns
   * true, the filter chain is terminated.
   *
   * The Matcher for the pattern can be retrieved via
   * getMatcherFromRequest (e.g. if groups are used in the pattern).
   */
  protected abstract boolean processMessage(HttpServletRequest req, HttpServletResponse res) throws ServletException;

  @Override
  public void doFilter(ServletRequest sreq, ServletResponse sres, FilterChain chain)
      throws IOException, ServletException {

    HttpServletRequest req = (HttpServletRequest) sreq;
    HttpServletResponse res = (HttpServletResponse) sres;

    MimeMessage message = getMessageFromRequest(req);
    Matcher m = applyPattern(req);

    if (m != null && processMessage(req, res)) {
      return;
    }

    chain.doFilter(req, res); // Try the next one

  }

  private Matcher applyPattern(HttpServletRequest req) {
    Matcher m = pattern.matcher(req.getServletPath());
    if (!m.matches()) m = null;

    req.setAttribute("matcher", m);
    return m;
  }

  protected Matcher getMatcherFromRequest(ServletRequest req) {
    return (Matcher) req.getAttribute("matcher");
  }

  protected MimeMessage getMessageFromRequest(ServletRequest req) throws ServletException {
    MimeMessage message = (MimeMessage) req.getAttribute("mimeMessage");
    if (message == null) {
      try {
        Properties props = new Properties();
        Session session = Session.getDefaultInstance(props, null);
        message = new MimeMessage(session, req.getInputStream());
        req.setAttribute("mimeMessage", message);

      } catch (MessagingException e) {
        throw new ServletException("Error processing inbound message", e);
      } catch (IOException e) {
        throw new ServletException("Error processing inbound message", e);
      }
    }
    return message;
  }
}

Controla el correo electrónico entrante

La API de JavaMail incluye la clase MimeMessage que puedes usar para analizar los mensajes de correo electrónico entrantes. MimeMessage tiene un constructor que acepta una java.io.InputStream y una sesión de JavaMail, que puede tener una configuración vacía.

Crea una instancia MimeMessage de la siguiente manera:

import java.io.IOException;
import java.util.logging.Logger;
import java.util.Properties;

import javax.mail.MessagingException;
import javax.mail.Session;
import javax.mail.internet.MimeMessage;

import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class MailHandlerServlet extends HttpServlet {

  private static final Logger log = Logger.getLogger(MailHandlerServlet.class.getName());

  @Override
  public void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
    Properties props = new Properties();
    Session session = Session.getDefaultInstance(props, null);
    try {
      MimeMessage message = new MimeMessage(session, req.getInputStream());
      log.info("Received mail message.");
    } catch (MessagingException e) {
      // ...
    }
    // ...
  }
}

Luego, puedes usar varios métodos para analizar el objeto message:

• Llama a getFrom() para que se muestre el remitente del mensaje.
• Llama a getContentType() para que se extraiga el tipo de contenido del mensaje. El método getContent() muestra un objeto que implementa la interfaz Multipart.
• Llama a getCount() para determinar la cantidad de partes.
• Llama a getBodyPart(int index) para que se muestre una parte del cuerpo en particular.

Después de configurar tu app para controlar el correo electrónico entrante, puedes usar la consola del servidor de desarrollo si deseas simular los mensajes de correo electrónico entrantes. Para obtener más información, incluido cómo iniciar el servidor de desarrollo, consulta El servidor de desarrollador Java. Después de iniciar la aplicación en el servidor de desarrollo local, puedes acceder a ella si visitas la URL http://localhost:8888/_ah/admin/. Reemplaza el valor 8888 por cualquier puerto que uses en caso de que no uses el puerto predeterminado para el servidor de desarrollo local.

En el servidor de desarrollo, haz clic en Inbound Mail en el lado izquierdo, completa el formulario que aparece y haz clic en Send Email.