Posts tagged ‘java’

Vérifier la validité d’un email avec Java

Un jour ou l’autre, à travailler dans le WEB, opn finit par devoir vérifier la validité d’un email. Comme on ne peut pas faire confiance à Javascript ou Flash pour vérifier les données envoyées par le client, il faut impérativement vérifier la validité des adresse mail coté serveur (au pire, vous risquez l’injection SQL). Voivi quelques pistes pour vérifier ces emails sur un serveur J2EE, ou sur n’importe quel conteneur de servlet (Tomcat,Jetty, Glassfish).

La solution de facilité

Voici un moyen simple rapide et à priori efficace d’effectuer cette vérification, à l’aide de la libraire apache « commons-validator »:

public static boolean validateEmailAddress(String votreEmail){
EmailValidator emailValidator = EmailValidator.getInstance();
return emailValidator.isValid(votreEmail);
}

Le fichier jar est disponible à cet endroit: http://commons.apache.org/validator/. A noter que ls utilitaires de validation Apache permettent de valider également les dates, ou encore les numéros de carte bleue, que ce soit en java, ou en javascript!

Prendre le taureau par les cornes, et chercher a implémenter la RFC 2822

C’est une usine à gaz, mais ca a été fait, en listant l’ensemble des tld(top level domains: .com, .net .org, etc) existants. C’est ce qui est réalisé ici:
http://www.velocityreviews.com/forums/t125158-java-email-validator.html

Implémenter sa propre regex simplifiée

On peut également essayer de construire soi-même sa fonction, en écrivant sa regex et en comparant la chaine de caractère à cette expression régulière. Suivre strictement les recommandations de la RFC 2822 est un vrai casse-tête (comme on a pu le voir un peu plus haut), et n’est pas forcément utile car l’email bien que valide n’est peut être pas réellement attribué a une personne !

Je vous conseille donc d’utiliser une regex simple, éprouvée, et testée:

^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}$

source: http://www.regular-expressions.info/email.html

Et voici l’implémentation correspondante:

public class Main {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
Console console = System.console();
if (console == null) {
System.err.println(« Probleme pour récupérer la console. »);
System.exit(1);
}
while (true) {
String a_tester = console.readLine(« Saisissez une adresse email à tester : « );
if(isEmailAdress(a_tester)) {
console.format(« OUI »);
}else{
console.format(« NON »);
}

}
}

public static boolean isEmailAdress(String email){
Pattern p = Pattern.compile(« ^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,4}$ »);
Matcher m = p.matcher(email.toUpperCase());
return m.matches();
}

}

Attention au caractère d’échappement (doublé dans la syntaxe Java) pour la déclaration du « . » dans la seconde partie de l’email!

18 février 2009 at 23 h 47 min 1 commentaire

Récupérer l’id (autoincrement) après un insert

Fiche recette du 12 février 2009:

Comment récupérér la valeur d’un champ déclaré « auto_increment » lors d’un INSERT INTO exécuté depuis Java ?

L’API JDBC fournit une méthode extrèmement pratique appelée getGeneratedKeys():

PreparedStatement stat = connectionSql.prepareStatement("INSERT INTO maTable SET " +
"login = ?," +
"email = ?");
int i=1;
stat.setString(i++, leLogin);
stat.setString(i++, leMail);
int nb_lignes = stat.executeUpdate();
ResultSet rs = stat.getGeneratedKeys();
int idAuto_increment = 0;
if( rs.next() ) {
idAuto_increment = rs.getInt(1);
}

Un enchainement de méthodes très certainement utile à connaitre… et que je recherche à chaque fois que je travaille avec MySql et son connecteur Java…

12 février 2009 at 20 h 30 min 2 commentaires

HOW TO: Read a file from jar and war files (java and webapp archive) ?

As many java programmers, i spent hours searching for the « good recipe » to read a txt file from my java archive to configure an application. The config file aren’t available to final users, so it should only help the programmer to configure his webapp, without having an external file / URL to check.

Reading a java archive would generally be done using the classloader of the JVM.

How to read from a jar file

The files you are looking to must be located in a directory named « classes » at the top of your src folder.
Unless your file exists, you will be able to open it as an URL or as a stream, using the application classloader.
To access to the class loader, just use your class, get the static  »class » instance pointer, and invoke getClassLoader method.
Then, use one of these two method:
getResourceAsStream() to have an input file
getResource() to have an URL object

If you try to open a file outside the classes folder, the classloader will throw a NullException.

InputStream in =
new InputStreamReader(FileLoader.class.getClassLoader().getResourceAsStream("file.txt") );

How to read from a war file

Here is what the tomcat documentation says about loading your own files shipped within your webapp archive:

WebappX – A class loader is created for each web application that is deployed in a single Tomcat 6 instance. All unpacked classes and resources in the /WEB-INF/classes directory of your web application archive, plus classes and resources in JAR files under the /WEB-INF/lib directory of your web application archive, are made visible to the containing web application, but to no others.

So it means you will use the /WEB-INF/classes directory. It means the code would be nearly the same as for a Desktop application jar file. Get a classloader from the classe you are coding (just change the name of it) and get your file.

The best way to look to a config file from a webapp is to implement the servlet method init().
Let’ try using the same code
InputStream in =
new InputStreamReader(FileLoaderServlet.class.getClassLoader().getResourceAsStream("file.txt") );

It works fine !

So just remember to put your into the right folder if you are getting an exception.

Reading files outside the classes folder ?

Theses articles will show you a simple way to achieve it for jar files:

http://java.sun.com/developer/JDCTechTips/2003/tt0122.html

For war files, don’t use the servlet container’s classloader, but use the ServletContext instead.

This method allows servlet containers to make a resource available to a servlet from any location, without using a class loader.

ServletContext context = getServletContext();
InputStream is = context.getResourceAsStream("/yourfilename.txt");

It is recommended to keep it under the /WEB-INF directory if you don’t want browers being able to access it.

The path must begin with a « / » and is interpreted as relative to the current context root. This method returns null if no resource exists at the specified path. For example ServletContext.getResourceAsStream(« WEB-INF/resources/yourfilename.cnf ») will return a nul exception, so be careful !

Happy coding.

19 octobre 2008 at 17 h 01 min 4 commentaires

Synthèse sur les structures de données / collections de Java 1.6

Un article plus technique que d’habitude aujourd’hui, dont le but va être d’avoir une vue globale des structures de type tableaux / listes en java.

Ma première expérience avec les structures de données remonte à l’époque des cours de MathSup où le cours d’informatique nous expliquait quand et pourquoi une liste chainée peut être plus efficace qu’un tableau. NOn nous demandait d’implémenter nous même nos propres algorithmes de tri / insertion / recherche en langage CAML, en priant Knuth, Stirling et leurs amis pour ne pas faire d’erreur 😉
Avec les l’évolution des langages modernes, proposant de nombreuses librairies il vaut mieux aujourd’hui bien savoir choisir ses structures de données plutot que de les implémenter soi même.

Bien choisir ses structures de données, donc avoir un aperçu clair des types de tableaux fournis par le langage, est primordial pour bien implémenter ses programmes. Voici une synthèses des notes de SUN intitulées « Introduction to the collection Framework » sur le thème des collections, disponibles ici:

Tutoriel de Sun

Des interface et des implémentations:

Le framework Collections propose des interfaces (elles permettent de standardiser les méthodes même pour des structures différentes). Intéressons nous à ces interfaces: il en existe 3 différentes:

Le Set

Collection, doublons non autorisés

La List

Collection, doublons autorisés, et systeme d’index implémenté pour accès rapide aux données

La Map

Ensemble de paires (par opposition à la collection), donc collections de données composées clé/valeur

Les implémentations disponibles sont les suivantes:

Interface Implémentation Historique
Set HashSet TreeSet
List ArrayList LinkedList Vector

Stack

Map HashMap TreeMap Hashtable

Properties

Méthodes disponibles pour trier / insérer / rechercher

Voici la liste des méthodes mises à disposition par l’interface Collection:

Ajouter / supprimer:
add(Element) et addAll(Collection)
clear()
remove(Element), removeAll(Collection), retainAll(Collection)
retainsAll se comporte comme l’intersection d’après le terme ensembliste

Rechercher / parcourir
contains(Element)
containsAll(Collection)
iterator() (retourne un objet itérateur qui permet de parcourir la collection avec hasNext())

Dénombrer
size()

Voir la javadoc

Les implémentations de Set

Hash Set et TreeSet sont disponibles.
Si vos données ne doivent pas avoir de doublon, utilisez un HashSet (temps constant).
Si elle doit en plus etre triée, prenez un TreeSet (insertions suppressions et recherches en Log(n))

Les implémentations de List

La liste permet d’avoir des données ordonnées et accepte les doublons.
Le choix doit être fait entre une liste chainée LinkedList et un tableau ArrayList.
Si de nombreuses insertions sont réalisées, alors la liste chainée est plus efficaces (temps constant contre temps linéaire pour la ArrayList). En revanche, l’accès aux données en fonction de l’index (méthode get()) est constant pour l’ArrayList et linéaire pour la liste chainée (obligation de parcourir tous les éléments…).

Les implémentations de Map

Les données ne sont pas ordonnées. L’insertion et l’accès aux valeurs se font grace a une clé.
Deux implémentations encore sont proposées. La hashMap et la TreeMap. La hash map réalise les opérations get et put en temps constant, mais le parcours (méthode contain) a une complexité linéaire. En revanche pour la treemap, l’insertion, le parcours, et l’accès aux données est réalisé aec une complexité de log(n).

Synthèse, que choisir ?

Les questions à se poser sont donc:
– ai-je des doublons ?
– dois-je privilégier le parcours ou l’inserstion suppression ?
– mes données doivent elles être ordonnée ?

Références:
Penser en java / Thinking in java de Bruce Eckel

Tutoriel de Sun

16 octobre 2008 at 15 h 08 min 1 commentaire

HOWTO: configure Tomcat to send mails, using javamail

This article shows step by step a way to configure Apache Tomcat J2EE server to send emails.

You will need first a working Tomcat server of course, and a mail server. You can have it on your own machine, just like me, so the smtp server would be « localhost », or on another machine from which you can use smtp, for instance your Internet Service Provider smtp (generally smtp.nameofyourISP.com)

Step 1 : Install the right libraries:

Sending mails with tomcat require 2 librairie: the javamail API, and the Java Activation Framework (jaf).
Depending on your JDK /JRE version, you will need to place 1 or 2 files in your /catalina_home/commons/libs/ folder.
If you have a 1.6 java version (check with java -version) you will need only the mail.jar otherwise, you will need both mail.jar and activation.jar.

Important: you must not include these two files into your webapp, or you will get an almost wired error:
java.lang.ClassCastException: javax.mail.Session cannot be cast to javax.mail.Session

Let’s download the files:

javamail-1_4_1.zip

With JDK / JRE 1.6 it’s the only one you will need. With other versions, take also this file: java activation framework

Unzip these file (if needed, on a Debian system for instance, download the zip package: apt-get unzip), and move it to the appropriate catalina folder (don’t forget to stop tomat service before).

mv /home/your_username/javamail-1.4.1/mail.jar /your_tomcat_home/common/lib/

The same applies to the activaction.jar if needed.

2. Configure your webapp:

2 step to configure your webapp. First, edit the conext.xml, and declare you mail ressource to make it available:

<Resource auth="Container" mail.smtp.host="localhost" name="mail/NomDeLaRessource" type="javax.mail.Session"/>

Next, edit your web.xml file and declare your webapp using your mail resource:

<resource-ref>
<description>Votre description </description>
<res-ref-name>mail/NomDeLaRessource</res-ref-name>
<res-type>javax.mail.Session</res-type>
<res-auth>Container</res-auth>
<res-sharing-scope>Shareable</res-sharing-scope>
</resource-ref>

3. Write the code

To test your configuration, here is a working sample code:

Session session = null;
try {
Context initCtx = new InitialContext();
Context envCtx = (Context) initCtx.lookup(« java:comp/env »);
session = (Session) envCtx.lookup(« mail/NomDeLaRessource »);

} catch (Exception ex) {
System.out.println(« lookup error »);
System.out.println( ex.getMessage());
}

Here is the code which actually send the mail:


Message message = new MimeMessage(session);
try {
message.setFrom(new InternetAddress(expediteur);
InternetAddress to[] = new InternetAddress[1];
to[0] = new InternetAddress(destinataire);
message.setRecipients(Message.RecipientType.TO, to);
message.setSubject(sujet);
message.setContent(corps, "text/html;charset=UTF-8");
Transport.send(message);
} catch (AddressException ex) {
System.out.println( ex.getMessage());
} catch (MessagingException ex) {
System.out.println( ex.getMessage());
}

The most convenient is to create a hepler method, with receiver adress, subject, body, etc…but that’s your work 🙂

Thanks goes to tomcat mailing list people, especially Chuck and Martin.

Références : tomcat.apache.org/

26 septembre 2008 at 9 h 27 min 10 commentaires

Installer le connecteur mysql java sur un serveur Tomcat

Nous allons installer le support de mysql au serveur Tomcat.

Il est important de ne pas dupliquer l’installation du connecteur (ne pas inclure dans le code source s’il n’est pas inclus.

il suffit de copier le fichier jar dans le dossier catalina_home/common/libs

Ainsi on fait un:

wget http://mir2.ovh.net/ftp.mysql.com/Downloads/Connector-J/mysql-connector-java-5.1.6.tar.gz

puis tar -zxvf ./mysql-connector-java-5.1.6.tar.gz

et enfin mv ./mysql-connector-java-5.1.6.tar.gz /catalinahome/common/libs/

et ca devrait être bon 🙂 N’oubliez pas de remplacer catalina_home par votre propre répertoire d’installation de Tomcat bien entendu…

23 septembre 2008 at 19 h 33 min Laisser un commentaire


Articles récents