Envoi d'un email en Java en utilisant JavaMail

L’envoi d’un email est le composant le plus simple à mettre en oeuvre pour contacter des acteurs en dehors de notre système d’information. Ces acteurs ne seront pas obligé d’ouvrir un compte ou d’installer des logiciels. Il suffit d’avoir un compte email.

Sous Java, l’API responsable de ce volet est JavaMail. Cette API garantit toutes les opérations liées aux emails : envoie, réception, lecture, classification, etc.

JavaMail est disponibles dans entrepôt GitHub accessible ici. Toutes les ressources nécessaires sont disponibles. Les exemples donnés (ici) sont aussi très claires et documentés.

La partie qui nous intéresse aujourd’hui est l’envoie d’un email. Le teste utilisera un compte Gmail pour envoyer un message texte simple.

Pour envoyer un email, il est nécessaire de manipuler les classes
suivantes :

• Properties : cette classe permet de stocker des propriétés, elle n’est pas propre à l’API JavaMail disponible dans le package java.util).
• Session : pour créer une sessiond d’envoie de messages. Session ici n’a pas le même sens de Session manipulée en J2EE.
• Message : l’objet principal. Il permet de créer le message à envoyer et contiendra toutes les  information nécessaire (emetteur, destinataire, contenu, date, etc.). Transport : qui permet de se connecter au serveur et d’envoyer le message réellement.

Les informations de base sont :

• Adresse email de l’expéditeur,
• Adresse(s) email de(s) destinataire(s),
• L’objet du message,
• Le corps du message.

Dans le cas de Gmail :

• Il est important de s’authentifié, ainsi, il faut :

• Activiter l’authentification en ajoutant la propriété :

props.put("mail.smtp.auth", "true");

• Il faut utiliser la classe transport SMTPTransport et de se connecter avant d’envoyer le message,
• Il faut utiliser le protocole smtps et non pas smtp au moment de la création de la classe SMTPTransport comme suit :

SMTPTransport t = (SMTPTransport)session.getTransport("smtps");

• Il faut activer l’option less secure apps sur le compte google à utiliser.

Ainsi, le code à utiliser sera le suivant (le mot de passe est lu à partir du clavier, il suffit d’appeler la méthode statique avec les trois paramètres nécessaires):

import com.sun.mail.smtp.SMTPTransport;
import java.util.Date;
import java.util.Properties;
import java.util.Scanner;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Session;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;

public class MailService {

    public static String SERVER = "smtp.gmail.com";
    public static String FROM = "votre_compte@gmail.com";

    public static void sendMail(String to, String subject, String content) throws MessagingException {
        
        Properties props = System.getProperties();
        props.put("mail.smtp.host", SERVER);
        props.put("mail.smtp.auth", "true");

        Session session = Session.getInstance(props, null);
        session.setDebug(true);

        Message msg = new MimeMessage(session);

        msg.setFrom(new InternetAddress(FROM));

        msg.setRecipients(Message.RecipientType.TO,
                InternetAddress.parse(to, false));

        msg.setSubject(subject);
        msg.setText(content);

        msg.setHeader("X-Mailer", "msgsend");
        msg.setSentDate(new Date());

        SMTPTransport t = (SMTPTransport)session.getTransport("smtps");
        
        String password = readPassword();
        t.connect("smtp.gmail.com", FROM, password);

        t.sendMessage(msg, msg.getAllRecipients());
        
        System.out.println("Response: " + t.getLastServerResponse());

    }
    
    public static String readPassword(){
        Scanner in = new Scanner(System.in);
        System.out.println("Enter password :");
        return in.nextLine();
    }

}

Vous pouver trouver une version PDF de ce post : ici.

[défi] Greed

Le défi est proposé sur la plateforme Dev.to sur le lien suivant Greed.

""
Greed is a dice game played with five six-sided dice. Using an array containing five six-sided dice values, write a function that will score a throw according to the following rules:

Three 1's => 1000 points
Three 6's => 600 points
Three 5's => 500 points
Three 4's => 400 points
Three 3's => 300 points
Three 2's => 200 points
One 1 => 100 points
One 5 => 50 point

A single die can only be counted once in each roll. For example, a "5" can only count as part of a triplet (contributing to the 500 points) or alone (as 50 points), but not both in the same roll.

Example Scoring

5 1 3 4 1 => 50 + 2 * 100 = 250
1 1 1 3 1 => 1000 + 100 = 1100
2 4 4 5 4 => 400 + 50 = 450
""

Ma proposition (simplifiée) est la suivante :

public class Greed {

    public static int[] scores = new int[]{1000, 200, 300, 400, 500, 600};

    public static int checkOccurrences(int[] dicesValues, int valueToCheck) {
        int numberOfOccurrences = 0;

        for (int i = 0; i < dicesValues.length; i++) {
            numberOfOccurrences += (dicesValues[i] == valueToCheck) ? 1 : 0;
        }

        return numberOfOccurrences;
    }

    public static void eraseThreeOccurences(int[] dicesValues, int valueToCheck) {
        int index = 0;
        int erased = 0;

        while (index < dicesValues.length && erased < 3) {
            if (dicesValues[index] == valueToCheck) {
                dicesValues[index] = 0;
                erased++;
            }
            index++;
        }
    }

    public static int playExample(int[] dicesValues) {

        int score = 0;

        for (int i = 0; i < scores.length; i++) {
            if (checkOccurrences(dicesValues, (i + 1)) >= 3) {
                score += scores[i];
                eraseThreeOccurences(dicesValues, (i + 1));
            }
        }

        score += 100 * checkOccurrences(dicesValues, 1);
        score += 50 * checkOccurrences(dicesValues, 5);

        return score;

    }

    public static void main(String[] args) {

        
        int[] example1 = new int[]{5, 1, 3, 4, 1};
        int[] example2 = new int[]{1, 1, 1, 3, 1};
        int[] example3 = new int[]{2, 4, 4, 5, 4};

        System.out.println("Example 1 " + playExample(example1));
        System.out.println("Example 2 " + playExample(example2));
        System.out.println("Example 3 " + playExample(example3));

        
    }

}

Une version plus complète peut être trouvée ici.