Ricezione della posta con l'API Mail

Questa guida descrive come utilizzare l'API Mail per ricevere email.

I messaggi email vengono inviati alla tua app come richieste HTTP. Per elaborare i messaggi email in arrivo, devi associare gli indirizzi email ai servlet nella configurazione dell'applicazione, quindi includere il codice servlet con la tua app. L'email in arrivo genera richieste HTTP che vengono passate ai servlet appropriati per la gestione.

Prima di iniziare

Devi registrare le email dei mittenti come mittenti autorizzati. Per saperne di più, consulta Chi può inviare email.

Configurare l'applicazione per ricevere email

Quando crei una nuova applicazione, le email in arrivo sono disattivate per impostazione predefinita. Se non attivi esplicitamente le email in arrivo, i messaggi inviati alla tua app vengono ignorati.

Per attivare il servizio di email in arrivo, modifica i appengine-web.xml e web.xml file di configurazione:

Attivare le email in appengine-web.xml

Modifica appengine-web.xml aggiungendo una sezione inbound-services che attiva il servizio di email in arrivo:

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

I messaggi email vengono inviati alla tua app come richieste HTTP POST utilizzando il seguente URL:

/_ah/mail/<ADDRESS>

dove <ADDRESS> è un indirizzo email completo, incluso il nome di dominio. Tieni presente che, anche se la tua app è sottoposta a deployment su un dominio personalizzato, non può ricevere email inviate agli indirizzi in quel dominio.

Attivare le email in web.xml

Modifica web.xml mappando gli URL delle email ai servlet:

<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>

Negli snippet precedenti, /_ah/mail/* corrisponde a tutte le email indirizzate all'app. I servlet di posta vengono eseguiti nella versione attualmente in pubblicazione della tua app in App Engine.

Invio dei messaggi in arrivo basato su pattern

Se la tua app utilizza la corrispondenza di pattern, valuta la possibilità di utilizzare un approccio basato su filtri in base ai seguenti snippet di codice.

Gestore 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;
  }
}

Il gestore concreto precedente viene registrato utilizzando il seguente snippet in 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>

Tieni presente che le direttive security-constraint non sono possibili sui filtri; le norme di sicurezza sul gestore dovranno essere introdotte in un altro modo.

Gestore astratto

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;
  }
}

Gestire le email in arrivo

L'API JavaMail include la classe MimeMessage che puoi utilizzare per analizzare i messaggi email in arrivo. MimeMessage ha un costruttore che accetta un java.io.InputStream e una sessione JavaMail, che può avere una configurazione vuota.

Crea un'istanza MimeMessage come segue:

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) {
      // ...
    }
    // ...
  }
}

Puoi quindi utilizzare vari metodi per analizzare l'oggetto message:

  • Chiama getFrom() per restituire il mittente del messaggio.
  • Chiama getContentType() per estrarre il tipo di contenuto del messaggio. Il getContent() metodo restituisce un oggetto che implementa l' Multipart interfaccia.
  • Chiama getCount() per determinare il numero di parti
  • Chiama getBodyPart(int index) per restituire una parte del corpo specifica.

Dopo aver configurato l'app per gestire le email in arrivo, puoi utilizzare la console del server di sviluppo per simulare i messaggi email in arrivo. Per saperne di più, incluso come avviare il server di sviluppo, consulta Il server di sviluppo Java. Dopo aver avviato l'applicazione nel server di sviluppo locale, puoi accedervi visitando l'URL http://localhost:8888/_ah/admin/, sostituendo il valore 8888 con la porta che stai utilizzando se non utilizzi la porta predefinita per il server di sviluppo locale.

Nel server di sviluppo, fai clic su Email in arrivo sul lato sinistro, compila il modulo visualizzato e fai clic su Invia email.