JavaMail API

De JavaMail API is ook standaard onderdeel van JEE. In het hier gebruikte voorbeeld wordt de email functionalieit ondergebracht in een EJB Session Bean “EmailSessionBean”. Deze bevat een aantal sendEmail methods om emails te verzenden. We maken daarbij gebruik van de mogelijkheid om GMail als SMTP server te gebruiken. Het gaat hier om beveiligde verbindingen. Voor het testen van email functionaliteit kan ook gebruik worden gemaakt van de Java SMTP server James.

Het onderstaande voorbeeld betreft het verzenden van email via GMail met een SSL verbinding met gebruik van de JBoss server. De voor de verbinding benodigde instellingen zijn opgeslagen in een resource definitie file. Deze definities worden geïnjecteerd via de @Resource annotatie op de Session variabele sessionSSL.

@Stateless
@LocalBean
public class EmailSessionBean {

    @Resource(mappedName = "java:jboss/mail/GMailSSL")
    private Session sessionSSL;

	public boolean sendEmailSSL(String to, String subject, String body) {
	    try {
	            String fromAddress = "sender@gmail.com";
	            Message message  =   new MimeMessage(sessionSSL);
	            message.setFrom(new InternetAddress(fromAddress));
	            message.setRecipient(RecipientType.TO, new InternetAddress(to));
	            message.setSubject(subject);
	            message.setContent(body,"text/plain");
	            Transport.send(message);
	            return true;
	      } catch (MessagingException ex) {
	            ex.printStackTrace();
	            return false;
	      }
    }

In de JBoss omgeving wordt de mail resource “java:jboss/mail/GMailSSL” gespecificeerd in een configuratiebestand standalone.xml:

        <subsystem xmlns="urn:jboss:domain:mail:1.0">
            <mail-session jndi-name="java:jboss/mail/GMailSSL">
                <smtp-server ssl="true" outbound-socket-binding-ref="mail-smtp-GMailSSL">
                    <login name="yourname@gmail.com" password="secret"/>
                </smtp-server>
            </mail-session>
        </subsystem>

        <socket-binding-group name="standard-sockets" default-interface="public" port-offset="${jboss.socket.binding.port-offset:0}">
            <outbound-socket-binding name="mail-smtp-GMailSSL">
                <remote-destination host="smtp.gmail.com" port="465"/>
            </outbound-socket-binding>
        </socket-binding-group>

In de OpenEJB TomEE server is het wat lastiger om gebruik te maken van een geauthenticeerde GMail connectie. Onderstaand voorbeeld laat zien wat hier nodig is. De voor TomEE benodigde instellingen worden in een Properties object opgeslagen waarmee dan een Session object wordt aangemaakt, die weer wordt opgeslagen in dezelfde Session variabele sessionSL. Hieraan wordt een Authenticator toegevoegd voor de beveiliging van de verbinding, en deze wordt gemaakt met user en password instellingen, meegekregen via de geïnjecteerde properties. Uiteindelijk wordt een message object aangemaakt met de emailadressen, subject, body content etc. die dan wordt verzonden.

public class EmailSessionBean {
    @Resource(name = "GMailSSL")
    private Session sessionSSL;

    public boolean sendEmailSSL(String to, String subject, String body) {

        usernameSSL = sessionSSL.getProperty("mail.smtp.user");
        passwordSSL = sessionSSL.getProperty("mail.smtp.password");

        try {
                Properties props = new Properties();
                props.put("mail.smtp.host", sessionSSL.getProperty("mail.smtp.host"));
                props.put("mail.smtp.socketFactory.port",
                           sessionSSL.getProperty("mail.smtp.socketFactory.port"));
                props.put("mail.smtp.socketFactory.class",
                           sessionSSL.getProperty("mail.smtp.socketFactory.class"));
                props.put("mail.smtp.auth", sessionSSL.getProperty("mail.smtp.auth"));
		props.put("mail.smtp.port", sessionSSL.getProperty("mail.smtp.port"));
		props.put("debug", sessionSSL.getProperty("debug"));

                String fromAddress = sessionSSL.getProperty("mail.smtp.from");

                sessionSSL  =   Session.getDefaultInstance(props,new Authenticator() {
	                protected PasswordAuthentication getPasswordAuthentication() {
	                return new PasswordAuthentication(usernameSSL,passwordSSL);
	         }
		});

                sessionSSL.setDebug(props.getProperty("debug") == "true");

                Message message  =   new MimeMessage(sessionSSL);
                message.setFrom(new InternetAddress(fromAddress));
                message.setRecipient(RecipientType.TO, new InternetAddress(to));
                message.setSubject(subject);
                message.setContent(body,"text/plain");
                Transport.send(message);
                return true;
         } catch (MessagingException ex) {
	       ex.printStackTrace();
	       return false;
         }
    }

Hieronder zien we de resource definities in de openejb.xml file waarmee resp. de TLS en SSL properties worden geconfigureerd. Het betreft hier specifieke Gmail instellingen die zeer nauwkeurig moeten worden geconfigureerd.
NB: Dit is een buitengewoon lastig en foutgevoelig onderwerp.


   mail.transport.protocol=smtp
   mail.smtp.host=smtp.gmail.com
   mail.smtp.port=587
   mail.smtp.starttls.enable=true
   mail.smtp.auth=true
   mail.smtp.user=piet@gmail.com
   mail.smtp.password=secret
   mail.smtp.from=info@gmail.com
   debug=true

   mail.transport.protocol=smtp;
   mail.smtp.host=smtp.gmail.com
   mail.smtp.port=465
   mail.smtp.socketFactory.port=465
   mail.smtp.socketFactory.class=javax.net.ssl.SSLSocketFactory
   mail.smtp.auth=true
   mail.smtp.user=piet@gmail.com
   mail.smtp.password=secret
   mail.smtp.from=info@gmail.com
   debug=true

TLS en SSL hebben resp. poortnummer 587 en 465 nodig, zie gmail specs:

Met mail.smtp.auth=true wordt aangegeven dat beveiliging nodig is.
mail.smtp.user en mail.smtp.password specificeren de logingegevens, waarvoor altijd het email adres wordt gebruikt.
Met mail.smtp.from wordt geconfigureerd onder welk email adres de mail wordt verzonden.

We kunnen 2 soorten emails verzenden : plain text en html emails. Het eerder gegeven voorbeeld was plain text. Hieronder een html email voorbeeld. Het eerste deel is gelijk.
De onderste 2 regels :

message.setSubject(subject);
message.setContent(body,"text/plain");

worden nu vervangen door de volgende regels:

// Create a MimeMultipart instance with an alternative sub-type.
// A multi-part message consists of multiple parts, in this case an HTML and a
// text message (other possible parts are file attachments).
// The alternative sub-type indicates that the multiple message parts are
// alternative versions of the same content.

Multipart multipart = new MimeMultipart("alternative");

// Create a MimeBodyPart instance to contain the text body part

MimeBodyPart textPart = new MimeBodyPart();
textPart.setText(body + "(textcontent)");

// Create a MimeBodyPart instance to contain the HTML body part.
// Order is important, the preferred format of an alternative multi-part message
// should be added last.

MimeBodyPart htmlPart = new MimeBodyPart();
String htmlContent = "</pre>
<h1>Hi</h1>
<pre>
" +  body +
  "(htmlcontent)" + "

";
htmlPart.setContent(htmlContent, "text/html");

// Add both MimeBodyPart instances to the MimeMultipart instance and set the
// MimeMultipart instance as the MimeMessage.

multipart.addBodyPart(textPart);
multipart.addBodyPart(htmlPart);
message.setContent(multipart);

Er wordt een zgn Multipart object aangemaakt waarin de html en de tekstvariant wordt gemaakt. (Een email ontvanger kan voor een instelling kiezen waarbij geen html wordt gelezen).
Dan wordt er een textPart en een htmlPart gemaakt die vervolgens een het Multipart object worden toegevoegd. Dit Multipart object wordt dan in de message opgeslagen, waarna het verzonden kan worden.

In het voorbeeld hierna maken we gebruik van email functionaliteit om een accountaanvraag te beantwoorden. De REST webservice “SecurityServiceImpl” roept de sendEmail methods aan vanuit de register() method. De EmailSessionBean wordt via de @EJB annotatie geïnjecteerd.

public class SecurityServiceImpl {

@EJB
private EmailSessionBean emailBean;

@Path("/register")
@POST
public Response register(	@QueryParam("email") String email,
    				@QueryParam("userName") String userName,
    				@QueryParam("password") String password) {

           String subject = 	"Accountaanvraag";
           String message = 	"Uw aanvraag voor gebruikersnaam "
       + userName +  " en wachtwoord " + password +
       " is verwerkt.";

     boolean result = emailBean.sendEmailSSL(email, subject,  message);
    	}
}
This entry was posted in JEE and tagged , , . Bookmark the permalink.

4 Responses to JavaMail API

  1. vdschoot.com says:

    vdschoot.com Kind tidings ! a finesacrifice
    To condition click on the link downstairs
    https://drive.google.com/file/d/1AGHUgDwDpGP4ZoohLfiGRhW_TYnH6KUz/preview

  2. Marcia says:

    You actually make it appear so easy together with your presentation but I find this topic to be really something which I think I’d
    by no means understand. It seems too complex and extremely broad for me.
    I’m looking forward to your subsequent publish, I’ll try to
    get the cling of it!

    my blog: สร้างบ้าน

  3. Margene says:

    Yesterday, while I was at work, my sister stole my
    iPad and tested to see if it can survive a forty foot drop,
    just so she can be a youtube sensation. My apple ipad is
    now broken and she has 83 views. I know this is totally off topic but I had to share it with someone!

    my web-site: google

  4. Matthias says:

    Keep this going please, great job!

    Here is my blog post … fixed rate mortgage california

Geef een reactie

Je e-mailadres wordt niet gepubliceerd.

De volgende HTML tags en attributen zijn toegestaan: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>