Archives pour la catégorie JAVA/JEE

Snippet #14 ~ JAVA : Crypter et décrypter une chaine de caractère

Mercredi, 25 janvier 2012

Salut !! Tout le monde s’en fout mais c’était mon anniversaire hier !!

Et à cette occasion, c’est moi qui vous fais cadeaux de ce petit snippet permettant de crypter ou de décrypter des String Java et ce en utilisant une clé de cryptage ainsi que les outils du package Cypher.

(en passant, je trouve inquiétant que ce package précis porte le nom du traître de Matrix mais bon…)

Crypter le mot de passe :

public String encrypt(String password,String key){ try { Key clef = new SecretKeySpec(key.getBytes("ISO-8859-2"),"Blowfish"); Cipher cipher=Cipher.getInstance("Blowfish"); cipher.init(Cipher.ENCRYPT_MODE,clef); return new String(cipher.doFinal(password.getBytes())); } catch (Exception e) { return null; } }

Décrypter le mot de passe :

public String decrypt(String password,String key){ try { Key clef = new SecretKeySpec(key.getBytes("ISO-8859-2"),"Blowfish"); Cipher cipher=Cipher.getInstance("Blowfish"); cipher.init(Cipher.DECRYPT_MODE,clef); return new String(cipher.doFinal(password.getBytes())); } catch (Exception e) { System.out.println(e); return null; } }

Si vous ne souhaitez pas utiliser la crypto Cypher, vous pouvez utiliser un code plus simple :

Crypter

    public String encrypt(String password){
        String crypte= »";
        for (int i=0; i<password.length();i++) {
            int c=password.charAt(i)^48;
            crypte=crypte+(char)c;
        }
        return crypte;
    }

Décrypter

    public String decrypt(String password){
        String aCrypter= »";
        for (int i=0; i<password.length();i++) {
            int c=password.charAt(i)^48;
            aCrypter=aCrypter+(char)c;
        }
        return aCrypter;
    }

Envoyer un sms en PHP, Java, Javascript ou depuis une url !

Dimanche, 11 décembre 2011

Salut à tous !! Je bricole en ce moment !! Et hier aprem j’étais sur un petit programme PHP/JAVA permettant de transformer son téléphone portable en webservice pour envoyer des SMS.

En effet il peux être pratique de pouvoir envoyer des sms depuis un script ou un programme, les applications sont multiples :

Pour avertir du down d’un serveur
Pour envoyer un code de confirmation a un internaute
Pour envoyer automatiquement un sms de joyeux anniversaire à un amis…
etc…etc…

Voila voila, avec mon petit programme vous pouvez donc envoyer des sms en tapant une url de ce type :

http://sms.idleman.fr/add/motDePasse/0687531254/Joyeuse fêtes mon poto !!

Explication de l’url :

sms.idleman.fr : Adresse vers votre script d’envois de sms

add: On indique qu’on souhaite ajouter un sms a la liste d’attente

motDePasse: On envois un mot de passe précédemment définis dans le script pour éviter que n’importe qui envois des sms avec votre portable

0687531254: On précise le numéro de portable du destinataire

Joyeuse fêtes mon poto !! : On précise le message à envoyer.

Bon à ce stade je pense que vous avez compris le principe, passons a la pratique !!

Avant tous les prérequis :

Prérequis :

Avoir un téléphone Android avec un forfait sms/internet illimité
Avoir un hébergement/serveur avec du PHP et une base Mysql et l’url rewriting activé.
Avoir deux sous de jugeote et savoir lire.

INSTALLATION

1) Dans votre base de donnée mysql, créez la base a partir du fichier pws.sql disponible
2) Configurez les accès a la base de données de la page index.php
3) Envoyez le répertoire pws contenant au moins index.php et .htaccess (assurez vous que votre serveur a l’url
rewriting activé).
4) Le service partie serveur est installé !! Passons à la partie téléphone !
5) Installez le fichiez PWS1.0.apk sur votre téléphone androïde
6) Lancez l’application PWS sur votre téléphone et configurez les paramètres suivants:
- ** hôte : Adresse url vers votre script php psw (ex: http://www.idleman.fr/pws)
  /!\ IMPORTANT : ne mettez pas de « / » à la fin de l’url !
- ** Mot de passe : Il s’agit du mot de passe du webservice, il dois impérativement correspondre au mot
  de passe ‘USER_UID’ de la page index.php.
- ** Rafraîchissement : Fréquence de la synchronisation entre votre téléphone et votre serveur, plus le
  temps sera court, plus vos sms seront envoyés vite, mais cela consommera plus de batterie sur votre téléphone.
7) Redémarrez votre téléphone, le script est installé !

UTILISATION

Pour envoyer un sms, ouvrez un navigateur et tapez l’adresse :

http://votre.serveur.fr/pws/add/votre.mot.de.passe.webservice/numero.destinataire/votre.message

exemple : http://www.idleman.fr/pws/add/UV$–z56e/0687865123/Halu mec !

Votre message sera envoyé dans un certain laps de temps en fonction de votre fréquence de rafraîchissement définis.

Vous pouvez donc appeler ce web-service en PHP (via curl) en JavaScript (via Ajax) en JAVA (via les httprequest) etc… et envoyer gratuitement et en illimité des sms depuis n’importe quel script ou langage (oai le principe du webservice quoi )

TÉLÉCHARGEMENT

Application androïde et script php ici : pws.zip

CRÉDITS

Script PHP, Application Androïde et concept par votre serviteur Idleman : http://blog.idleman.fr

La regex ultime pour vérifier la validité d’un email

Samedi, 19 novembre 2011

Woaw !! Voici l’expression régulière correcte pour vérifier la validité d’une adresse email :

(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t]
)+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:
\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(
?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[
\t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\0
31]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\
](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+
(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:
(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z
|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)
?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\
r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[
 \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)
?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t]
)*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[
 \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*
)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t]
)+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)
*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+
|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r
\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:
\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t
]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031
]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](
?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?
  ?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?
:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)|(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?
  ?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?
[ \t]))*"(?:(?:\r\n)?[ \t])*)*:(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\".\[\]
\000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|
\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>
@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"
(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t]
)*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?
:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[
\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\".\[\] \000-
\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(
?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;
:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([
^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"
.\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\
]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\
[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\
r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\]
\000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]
|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\".\[\] \0
00-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\
.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,
;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?
:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*
(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".
\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[
^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]
]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)(?:,\s*(
?:(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(
?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[
\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t
])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t
])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?
:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|
\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:
[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\
]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)
?[ \t])*(?:@(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["
()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)
?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>
@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[
 \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,
;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t]
)*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?
(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".
\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:
\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[
"()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])
*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])
+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\
.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z
|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(
?:\r\n)?[ \t])*))*)?;\s*)

Bon ben on vas plutôt faire confiance aux internautes hein :p !!

Source : sebsauvage.net

SVNKit, une librairie simple pour gérer les dépots SVN en JAVA

Mardi, 8 novembre 2011

Dans le cadre de mon projet SaD (Synchronize All Directories) dont je vous parlerais bientôt dans ma rubrique projet, j’ai besoin de manipuler des dépôts SVN depuis un client JAVA.

Et il se trouve que j’ai trouvé une super librairie gratuite simple et efficace comme je les aime pour ça, alors je vous la fait partager !!

http://www.svnkit.com/

Pour l’installer :

Cliquez ici : http://www.svnkit.com/download.php et téléchargez la dernière version stable Standalone (au moment ou je vous ecris : org.tmatesoft.svn_1.3.6.1.standalone.zip )
de zippez le bousin et récupérez tous les .jar qui se trouvent dans le dossier « lib »
Créez votre projet JAVA sur eclipse
faites glisser les .jar de votre dossier décompressé vers votre projet java (copy files –> ok)
clic droit sur votre projet Java –> Build path –> Configure build path
Add Jar –> déployez le dossier de votre projet, sélectionnez tous les jar –> ok

Le projet est installé !! Vous n’avez plus qu’à parcourir la marche à suivre sur le wiki et la doc de SVNKit.

… Allez comme je suis un grand prince je vous donne en bonus deux classes de ma création qui simplifient encore plus le processus :

Téléchargez :
Svn.java et
SvnEntry.java et incluez les dans votre projet Java

Vous pouvez maintenant créer une page main avec le code suivant :

public static void main(String[] args) {

		Svn svn = new Svn();
		//On definis l'url du dépot subversion
		svn.setUrl("http://xxx.xxx.xx.xx/svn/MonDepot");
		//On définis l'identifiant pour accèder au dépot (si l'accès est anonyme, ne rien définir)
		svn.setLogin("monLogin");
		//On définis le mot de passe pour accèder au dépot (si l'accès est anonyme, ne rien définir)
		svn.setPassword("monPassword");

		//on se connect au svn
		if(svn.connect()){

			//On récupere la liste des dossier et fichiers du dépot a partir de la racine (donc le chemin "")
			try {
				List<SvnEntry> tree= svn.list("");
				//Pour chaques élément récupéré
				for (int i = 0; i < tree.size(); i++) {
					SvnEntry entry = tree.get(i);
					//On imprime les infos de l'élément dans la console
					System.out.println(entry.toString());
				}
			} catch (SVNException e) {
				System.out.println("listing de '' impossible : "+e);
			}
		}else{
			System.out.println("connexion impossible");
		}
	}

Ace ajax, un IDE en javascript

Mercredi, 28 septembre 2011

Voila un éditeur type éclipse (bref un IDE) entièrement conçu en javascript (standalone en plus !!) le gros avantage de ce script est bien entendu qu’il peut être intégré à un site web et donc être accessible de partout en « cloud » si j’ose dire ^^ .

Plus qu’un simple colorateur de syntaxe, ace est capable de gérer les erreurs de syntaxes, l’indentation, les raccourcis clavier, la recherche/remplacement de caractères etc…

Le script peux s’appliquer nativement à de nombreux langages tels que :

Javascript
HTML
CSS
XML
Python
PHP
Java
Ruby
C++
CoffeeScript

Avec possibilité de créer de nouveau langages (un peu de bonne volonté et quelques notions de javascript seront requise)

Le script dispose également de nombreux thèmes graphiques et autres bidouilles à customiser, je vous laisse découvrir par vous même sur le site officiel.
Site : http://ace.ajax.org/

Démonstration : http://ace.ajax.org/build/kitchen-sink.html

Ressource #1 ~ Classe JAVA de gestion simple des dates

Mardi, 23 août 2011

Voici une petite classe maison qui étend la classe date de java et permet de la manipuler sans trop se prendre la tête, voici les fonctionnalités proposées:

conversions
comparaisons
opérations
récupération

Télécharger : IdleDate.java

Voiçi les méthodes proposées par la classe :

`parseString`


public static java.util.Date parseString(java.lang.String string,
                                         java.lang.String format)

Convertis une Chaine en Date
 



Type Parameters: 
String - chaine a convertir (ex : "12/11/2011") 
String - format de la chaine a converir (ex :pour  "12/11/2011" le format est "dd/MM/yyy")

Returns: 
 date





toString
public java.lang.String toString(java.lang.String format)

Exprime une date sous forme de chaine (ex : "12/12/2011 14:23:10")
 



Type Parameters: 
String - format de sortie (ex : pour "12/12/2011 14:23:10" est "dd/MM/yyyy kk:mm:ss")

Returns: 
 chaine de la date





toString
public static java.lang.String toString(java.util.Date date,
                                        java.lang.String format)

Exprime une date sous forme de chaine (ex : "12/12/2011 14:23:10")
 



Type Parameters: 
Date - Date a exprimer sous forme de chaine 
String - format de sortie (ex : pour "12/12/2011 14:23:10" est "dd/MM/yyyy kk:mm:ss")

Returns: 
 chaine de la date





difference
public java.util.HashMap<java.lang.String,java.lang.Integer> difference(java.util.Date date)

Compare deux dates et retour le nombre de millisecondes,minutes,heures,jours,mois et années de différence
 



Type Parameters: 
Date - date a comparer avec l'objet courant

Returns: 
 HashMap contenant les millisecondes,minutes,heures,jours,mois et

années de différence ex : myIdleDate.difference(new Date()).get("MONTH")

 

MILLISECOND : nombres de millisecondes de différences
SECOND : nombres de secondes de différences
MINUTE : nombres de minutes de différences
HOUR : nombres d'heures de différences
DAY : nombres de jours de différences
MONTH : nombres de mois de différences
YEAR : nombres d'années de différences







isOlder
public boolean isOlder(java.util.Date date)

Compare la date courante avec une autre date
 



Type Parameters: 
Date - date à comparer a l'objet courant

Returns: 
 si la date courante est plus vielle que la date indiquée en parametre, retourne true, sinon retourne false





isOlder
public static boolean isOlder(java.util.Date date0,
                              java.util.Date date)

Compare la date courante avec une autre date
 



Type Parameters: 
Date - date1 à comparer à date2 
Date - date2 à comparer à date1

Returns: 
 si la date1 est plus vielle que la date2 , retourne true, sinon retourne false





addMillisecond
public void addMillisecond(int millisecond)

Ajoute un nombre de millisecondes a la date courante
 



Type Parameters: 
int - nombre de millisecondes à ajouter





removeMillisecond
public void removeMillisecond(int millisecond)

Soustrait un nombre de millisecondes a la date courante
 



Type Parameters: 
int - nombre de millisecondes à soustraire





addSecond
public void addSecond(int second)

Ajoute un nombre de secondes a la date courante
 



Type Parameters: 
int - nombre de secondes à ajouter





removeSecond
public void removeSecond(int second)

Soustrait un nombre de secondes a la date courante
 



Type Parameters: 
int - nombre de secondes à soustraire





addMinute
public void addMinute(int minute)

Ajoute un nombre de minutes a la date courante
 



Type Parameters: 
int - nombre de minutes à ajouter





removeMinute
public void removeMinute(int minute)

Soustrait un nombre de minutes a la date courante
 



Type Parameters: 
int - nombre de minutes à soustraire





addHour
public void addHour(int hour)

Ajoute un nombre d'heures a la date courante
 



Type Parameters: 
int - nombre d'heures à ajouter





removeHour
public void removeHour(int hour)

Soustrait un nombre d'heures a la date courante
 



Type Parameters: 
int - nombre d'heures à soustraire





addDay
public void addDay(int days)

Ajoute un nombre de jours a la date courante
 



Type Parameters: 
int - nombre de jours à ajouter





removeDay
public void removeDay(int days)

Soustrait un nombre de jours a la date courante
 



Type Parameters: 
int - nombre de jours à soustraire





addMonth
public void addMonth(int month)

Ajoute un nombre de mois a la date courante
 



Type Parameters: 
int - nombre de mois à ajouter





removeMonth
public void removeMonth(int month)

Soustrait un nombre de mois a la date courante
 



Type Parameters: 
int - nombre de mois à soustraire





addYear
public void addYear(int year)

Ajoute un nombre d'années a la date courante
 



Type Parameters: 
int - nombre d'années à ajouter





removeYear
public void removeYear(int year)

Soustrait un nombre d'années a la date courante
 



Type Parameters: 
int - nombre d'années à soustraire





getMillisecond
public int getMillisecond()

Retourne le nombre de millisecondes de la date courante
 



Returns: 
 nombre de millisecondes de la date courante





getSecond
public int getSecond()

Retourne le nombre de secondes de la date courante
 



Returns: 
 nombre de secondes de la date courante





getMinute
public int getMinute()

Retourne le nombre de minutes de la date courante
 



Returns: 
 nombre de minutes de la date courante





getHour
public int getHour()

Retourne l'heure de la date courante
 



Returns: 
 heure de la date courante





getDayMonth
public int getDayMonth()

Retourne le jour du mois de la date courante
 



Returns: 
 jour du mois de la date courante





getMonth
public int getMonth()

Retourne le mois de la date courante
 



Overrides: 
getMonth in class java.util.Date




Returns: 
 mois de la date courante





getYear
public int getYear()

Retourne l'année de la date courante
 



Overrides: 
getYear in class java.util.Date




Returns: 
 année de la date courante





getMillisecond
public static int getMillisecond(java.util.Date date)

Retourne le nombre de millisecondes de la date courante
 



Returns: 
 nombre de millisecondes de la date courante





getSecond
public static int getSecond(java.util.Date date)

Retourne le nombre de secondes de la date courante
 



Returns: 
 nombre de secondes de la date courante





getMinute
public static int getMinute(java.util.Date date)

Retourne le nombre de minutes de la date courante
 



Returns: 
 nombre de minutes de la date courante





getHour
public static int getHour(java.util.Date date)

Retourne l'heure de la date courante
 



Returns: 
 heure de la date courante





getDayMonth
public static int getDayMonth(java.util.Date date)

Retourne le jour du mois de la date courante
 



Returns: 
 jour du mois de la date courante





getMonth
public static int getMonth(java.util.Date date)

Retourne le mois de la date courante
 



Returns: 
 mois de la date courante





getYear
public static int getYear(java.util.Date date)

Retourne l'année de la date courante
 



Returns: 
 année de la date courante





getTimestamp
public long getTimestamp()

Retourne le timestamp de l'objet courant sous forme de long
 



Returns: 
 timestamp

Snippet #7 ~ JAVA Faire une requete http en POST et en GET

Vendredi, 19 août 2011

il peut être intéressant dans un programme Java Se, de savoir effectuer une requête vers le web (en GET ou en POST), voiçi deux petites méthodes tirées de ma classe HttpTools perso qui peuvent vous être utiles :

Appel d’une page en GET :

la méthode s’utilise très simplement :

String retourDeLaPage = get(« http://www.perdu.com »);

Si vous souhaitez ajouter des paramètres, il suffit de les inclure dans l’url (étant donné qu’il s’agit du requête GET) :

String retourDeLaPage = get(« http://www.perdu.com?pseudonyme=Idleman&pasword=danstesreves »);

public static String get(String url) throws IOException{

String source ="";
URL oracle = new URL(url);
URLConnection yc = oracle.openConnection();
BufferedReader in = new BufferedReader(
new InputStreamReader(
yc.getInputStream()));
String inputLine;

while ((inputLine = in.readLine()) != null)
source +=inputLine;
in.close();
return source;
}

Appel d’une page en POST:

public static String post(String adress,List<String> keys,List<String> values) throws IOException{
String result = "";
OutputStreamWriter writer = null;
BufferedReader reader = null;
try {
//encodage des paramètres de la requête
String data="";
for(int i=0;i<keys.size();i++){
if (i!=0) data += "&";
data +=URLEncoder.encode(keys.get(i), "UTF-8")+"="+URLEncoder.encode(values.get(i), "UTF-8");
}
//création de la connection
URL url = new URL(adress);
URLConnection conn = url.openConnection();
conn.setDoOutput(true);


//envoi de la requête
writer = new OutputStreamWriter(conn.getOutputStream());
writer.write(data);
writer.flush();




//lecture de la réponse
reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
String ligne;
while ((ligne = reader.readLine()) != null) {
result+=ligne;
}
}catch (Exception e) {
e.printStackTrace();
}finally{
try{writer.close();}catch(Exception e){}
try{reader.close();}catch(Exception e){}
}
return result;
}

la méthode s’utilise très simplement :

List<String> keys = new ArrayList<String>();

List<String> values= new ArrayList<String>();

keys.add("pseudonyme");

keys.add("password");

values.add("idleman");

values.add("danstesreves");

String retourDeLaPage = post("http://www.perdu.com",keys,values);

Snippet #6 ~ JAVA Récuperer le chemin absolu du jar executable

Vendredi, 19 août 2011

Voici un petit code très simple qui peux en sauver plus d’un ^^.

J’ai un peu galéré pour le trouver, non pas que mon amis google ne me renvois aucun résultat, bien au contraire, mais curieusement , ce sont les bidouilles de codes hyper complexe a deux euros qui arrivent en premier résultats. Espérons que mon post remontera cette petite méthode dans l’estime de gogole :

String urlCourante = getClass().getProtectionDomain().getCodeSource().getLocation().getFile();

Snippet #5 ~ JAVA conversion String > Date et Date > SQL Date

Mercredi, 29 juin 2011

La gestion des dates en java est, à mon sens, extrêmement compliquée à appréhender pour quelque chose de si simple à la base.

Voici deux petits codes qui limitent la chute des cheveux :

Convertir une chaine (String) en date (Date) :


String maDateString = "24/01/1988";
SimpleDateFormat typeFormat = new SimpleDateFormat( "dd/MM/yyyy" );
Date maDateFinale = typeFormat.parse( maDate);

Convertir une Date JAVA en Date SQL :

java.util.Date maDateJava =new java.util.Date();java.sql.Date maDateSQL = new java.sql.Date(maDateJava.getTime());

Snippet #4 ~ Modifier des clé de registre Windows en JAVA

Lundi, 20 juin 2011

Java ne comprend aucune librairie native permettant de manipuler les clé de registre de windows, normal, Java c’est portable, les clé de registre c’est typiquement windows.

Donc je suis contraint de passer par un vieux .reg ou un dll tous pourris?

Hé bien non ! Certaines librairies en pur Java existent pour manipuler les clé de registre, il en existe 3 ou 4, personnellement j’utilise celle qui me parais la plus simple et rapide d’utilisation : JavaRegistryWrapper.

Voiçi un exemple d’utilisation permettant de lancer automatiquement votre programme au demarrage de windows (et ceci en créant une valeur sur la clé de registre HKEY_CURRENT_USER/Software/Microsoft/Windows/CurrentVersion/Run) :

Télécharger le .jar librairie JavaRegistryWrapper
Inclure le jar dans le buildpath du projet (sous eclipse : clic droit sur le projet > Build path>configure build path>onglet libraries>add External Jar )
On peux faire péter le code :

package fr.idleman.example;

import org.snipecode.reg.RegUtil;

public class Registre {

	public static String get(String chemin,String clef)
	{
		String valeur = null;
		int handle = RegUtil.RegOpenKey(RegUtil.HKEY_CURRENT_USER, chemin,RegUtil.KEY_ALL_ACCESS)[RegUtil.NATIVE_HANDLE];
		byte[] val = RegUtil.RegQueryValueEx(handle, clef);

		if(null!=val){
			valeur = new String(val).toString().trim();
		}
		RegUtil.RegCloseKey(handle);
		return valeur;
	}

	public static void set(String chemin,String clef,String valeur)
	{
		int handle = RegUtil.RegOpenKey(RegUtil.HKEY_CURRENT_USER, chemin,RegUtil.KEY_ALL_ACCESS)[RegUtil.NATIVE_HANDLE];
		RegUtil.RegSetValueEx(handle, clef, valeur);
		RegUtil.RegCloseKey(handle);
	}

	public static void create(String chemin,String clef,String valeur)
	{
		int handle = RegUtil.RegCreateKeyEx(RegUtil.HKEY_CURRENT_USER, chemin)[RegUtil.NATIVE_HANDLE];
		RegUtil.RegCloseKey(handle);
		handle = RegUtil.RegOpenKey(RegUtil.HKEY_CURRENT_USER, chemin,RegUtil.KEY_ALL_ACCESS)[RegUtil.NATIVE_HANDLE];
		RegUtil.RegSetValueEx(handle,clef,valeur);
		RegUtil.RegCloseKey(handle);

	}

}
Une fois votre classe de gestion des Registre créé, vous pouvez créer votre Main :
package fr.idleman.example;
import org.snipecode.reg.RegUtil;
import fr.idleman.example.Registre;
public class Principal {
 public static void main (String[] args){
//Creer la clé
Registre.create("Software\\Microsoft\\Windows\\CurrentVersion\\Run","ExampleProgramme", "c:\\ExampleProgramme.exe");
//Modifier la clé
Registre.set("Software\\Microsoft\\Windows\\CurrentVersion\\Run","ExampleProgramme", "d:\\NewPath\\ExampleProgramme.exe");
//Recuperer la clé
String valeurChemin = Registre.get("Software\\Microsoft\\Windows\\CurrentVersion\\Run","ExampleProgramme");
System.out.println("Le chemindu programme est : "+valeurChemin);
}
}