Eclipse et les templates Java par l'exemple
Les templates d'Eclipse ou modèles sont des fragments réutilisables de code. Quelques lignes de code à insérer avec CTRL+ESPACE en utilisant le " Content Assist " dans un fichier source (Java, xml, html etc)
Quand on utilise souvent quelques lignes de code, il est intéressant de les mettre dans un template (modèle) pour pouvoir l'insérer à volonté, sans être obligé de retaper tout.
Un certain nombre de templates sont prédéfinis. Ils correspondent aux instructions de base du langage utilisé. Il est possible d'éditer les templates prédéfinis, et de créer des templates personnels.
Des variables prédéfinies peuvent être utilisées lors de la création des templates (date, nom d'une méthode, nom de types, nom de l'utilisateur, etc.)
Eclipse dispose d'un système intelligent de templates. Eclipse propose Les templates selon le contexte en cours. Si on est en train d'écrire des instructions Javadoc Eclipse propose des templates créés avec le contexte Javadoc. Idem pour le contexte Java.
Le système de templates n'est pas exclusivement utilisable dans Java, il existe dans beaucoup de langages.
Ce tutoriel se concentre sur l'utilisation des templates dans Java, mais les instructions abordées et les variables de templates sont la plupart de temps applicables dans d'autres langages.
Les templates mentionnés ici sont les templates utilisables pendant l'édition de programmes. D'autres templates existent sous Eclipse pour Java comme par exemple les templates de code utilisés, pour générer automatiquement des classes et ses composants.
La version de Java utilisée est 6 update 10
Eclipse 3.4
Utiliser des templates
Dans l'éditeur on tape les premières lettres d'un template suivi de CTRL+ESPACE. Si plusieurs templates commencent par ces lettres, une fenêtre pop-up est affichée pour laisser l'utilisateur choisir le template qu'il désire insérer à l'emplacement du curseur. Si un seul template commence par les lettres, il est inséré automatiquement, si le choix de l'insertion automatique est sélectionné lors de la création du template.
Exemple la méthode " main "
Parmi les templates fournis dans Eclipse, un template pour la création de " main ".
Taper " main " puis CTRL+ESPACE
Une fenêtre de choix s'ouvre. Sélectionner " main " puis ENTER, une méthode " main " est insérée
,Navigation dans un template
Dans un éditeur Java, taper " for " puis CTRL+ESPACE, plusieurs choix sont disponibles. Sélectionner " for – iterate over array ".
Les variables " i " sont mises en brillance dans le fichier source. Une autre variables est dans le template c'est " args "
Il est possible de se déplacer entre les variables en utilisant " TAB " et " TAB +SHIFT ", tant qu'on est en mode édition à l'intérieur du template. Un clic en dehors ou ENTER ou ESC permet de sortir de ce mode.
Modifier une " i " met de suite les autres variables " i " à jour automatiquement.
,Editer/Modifier des templates
Plusieurs méthodes sont disponibles pour éditer des templates
Window -> Preferences -> Java -> Editor -> Templates
Un clic sur " New "
Boutons :
New... Ajouter un nouveau template
Edit... Editer le template sélectionné
Remove Effacer les templates sélectionnés
Restore Removed Restaurer les templates prédéfinis effacés
Revert to Default Restaurer les valeurs par défaut (uniquement templates prédéfinis)
Import Importer des templates à partir d'un fichier de templates (fichier xml)
Export Exporter les templates sélectionnés dans un fichier xml
Use code
formatter Utiliser les préférences dans "Code Formatter dans
preferences" pour formater des templates
,Eclipse 3.4
Window -> Show View -> Templates.
Une vue est ajoutée permettant l'édition des templates (barre d'outils)
,Dans un éditeur Java
Sélectionner des lignes de code -> Alt+Shift+Z les templates correspondants au contexte sont affichés
Un clic sur "Configure Templates" pour ouvrir l'éditeur de templates
,L'éditeur de templates
-
Nom du template, le nom permet d'appeler le template
-
Description, très important permettant de distinguer plusieurs templates portant le même nom
-
Contexte du template. Dans quel contexte ce template doit être proposé et quelles sont les variables prédéfinies disponibles dans ce contexte.
-
Insertion automatique (si un template unique)
-
Pattern : le corps du template
-
Insert variables. Permet de consulter les variables prédéfinies avec une petite explication.
,Les variables prédéfinies
Un clic sur " Insert Variable " permet de sélectionner une variable prédéfinies. Des variables sont sélectionnées au moment de l'écriture d'une template et évaluées avant que l'expression ne soit insérée dans le code source. Quelques variables sont évaluées différemment selon le contexte du fichier source.
,Les variables de l'utilisateur
Définies par l'utiliser :
Il est possible de leur donner n'importe quel nom au choix (le nom ne doit pas être celui d'une variable prédéfinie)
Il est possible d'utiliser plusieurs fois la même variable dans le même template, chaque utilisation est un lien vers la même variable utilisée avant.
Par exemple ${msg} est une variable utilisateur et insérée comme tel dans le source.
System.out.println(" ${msg} ");
,Création de nouveaux templates :
Dans un template on écrit des instructions Java en utilisant une combinaison de variables utilisateurs et des variables prédéfinies.
,Format de variables :
Chaque variable commence avec le signe de " dollar " $. Les données sont dans deux accolades. " { } "
Simple :
${array}
Variable prédéfinie, évaluée dans le code comme un tableau de variables (array). Il est possible d'utiliser cette variable plusieurs fois dans le même template
Complexe :
${chaine:var(String)}
Le nom de la variable " chaine " est au choix de l'utilisateur, elle désigne une chaîne de caractères ou (String). Après définition, la variable " ${chaine} " désigne la chaîne définie avant. Ceci est bien sûr dans le même template.
Dans la suite de ce tutoriel une présentation des variables prédéfinies avec un exemple d'utilisation.
,Variables utilisées dans les contextes Java et Javadoc
${cursor}
${date}
${dollar}
${enclosing_method}
${enclosing_method_arguments}
${enclosing_package}
${enclosing_project}
${enclosing_type}
${file}
${line_selection}
${primary_type_name}
${return_type}
${time}
${user}
${word_selection}
${year}
,Variables supplémentaires utilisées le contexte Java
En plus des variables pour " java et javadoc ", les variables suivants sont utilisables dans un contexte java :
${id:argType(variable, n)}
${array}
${array_element}
${array_type}
${collection}
${id:elemType(variable)}
${exception_variable_name}
${id:field(type[,type]*)}
${index}
${iterator}
${iterable}
${iterable_element}
${iterable_type}
${:import(type[,type]*)}
${:importStatic([qualifiedName[,qualifiedName]*])}
${id:link(proposal[,proposal]*)}
${id:localVar(type[,type]*)}
${id:newName(reference)}
${id:newType(qualifiedTypeName)}
${todo}
${id:var(type[,type]*)}
,${dollar}
Le symbole dollar $
Template :
//contexte Java
System.out.println("Le cours actuel de doller ${dollar}");
Exemple de l'utilisation :
====================
package fr.iipt.ka.templates;
/**
*
Projet : test-templates
Fichier: TestTemplates.java
Package: fr.iipt.ka.templates
@author: Kaesar ALNIJRES
*/
public class TestTemplates {
public static void main(String[] args)
{
System.out.println("Le cours actuel de doller $");
}
}
,${id:argType(c, n)}
" argType " est le numéro " n " argument de la variable "c". " c " est une variable définie dans le template. Dans l'exemple argType est l'argument " 0 " de " c ", qui est de type " java.util.List "
Template :
=========
//contexte Java
${type:argType(c,0)} ${first:name(type)}=${c:var(java.util.List)}.get(0);${cursor}
Exemple d'utilisation :
======================
package fr.iipt.ka.templates;
import java.util.*;
import java.io.*;
/**
* @author Kaesar ALNIJRES
*
*/
public class TestTemplates {
private static String c = "Chaine de caractère";
public static void main(String[] args)
{
String[] chaines={"hello","world"};
List list=new ArrayList();
list.add(new File("hello.txt"));
File first=list.get(0);
}
}
,${array}
Est remplacée par un tableau (array) visible à cette endroit
Dans l'exemple le mot associé au modèle (template) suivi de CTRL+ESPACE est remplacé après (String[] args), par " args " et après " chaines " par " chaines " avec les propositions de deux arrays visibles.
Template :
=========
//contexte Java
if(${array}.length == 0)
System.out.println("Pas d\'arguments");
else
System.out.println("nombre d\'arguments "+${array}.lenghth);
Exemple d'utilisation
=================
package fr.iipt.ka.templates;
package fr.iipt.ka.templates;
/**
* @author Kaesar ALNIJRES
*
*/
public class TestTemplates {
public static void main(String[] args) {
if (args.length == 0)
System.out.println("Pas d\'arguments");
else
System.out.println("nombre d\'arguments " + args.length);
String[] chaines=null;
if (chaines.length == 0)
System.out.println("Pas d\'arguments");
else
System.out.println("nombre d\'arguments " + chaines.length);
}
}
,${array_element}
L'évaluation de cette variable donne un nom pour un nouveau variable locale correspondant à un élément d'un tableau ou array.
Template :
=========
//contexte Java
for (int ${index} = 0; ${index} < ${array}.length; ${index}++) {
${array_type} ${array_element} = ${array}[${index}];
${cursor}
}
Exemple d'utilisation :
======================
package fr.iipt.ka.templates;
import java.io.File;
/**
*
Projet : test-templates
Fichier: TestTemplates.java
Package: fr.iipt.ka.templates
@author: Kaesar ALNIJRES
*/
public class TestTemplates {
public static void main(String[] args)
{
for (int i = 0; i < args.length; i++) {
String string = args[i];
}
int[] a=new int[25];
for (int i = 0; i < a.length; i++) {
int j = a[i];
}
}
}
,${array_type}
Le type d'un tableau (array) visible à cet endroit.
Dans l'exemple le mot associé au modèle (template) suivi de CTRL+ESPACE est remplacé après (String[] args), par " String " et après " tableauInteger " par " Integer" avec les propositions de deux arrays visibles.
Template :
==========
//contexte Java
${array_type}[] ${result:newName(array)} = new ${array_type}[${array}.length];
Exemple d'utilisation
=================
package fr.iipt.ka.templates;
import java.io.File;
/**
*
Projet : test-templates
Fichier: TestTemplates.java
Package: fr.iipt.ka.templates
@author: Kaesar ALNIJRES
*/
public class TestTemplates {
public static void main(String[] args)
{
String[] args2 = new String[args.length];
int[] a=new int[25];
int[] a2 = new int[a.length];
}
}
,${collection}
L'évaluation de cette variable donne le nome d'une collection visible à cet endroit
Template :
==========
//contexte Java
for(${type:elemType(collection)} ${file:newName(type)}: ${collection})
{
System.out.println(${file}.getName() );
}
Exemple d'utilisation :
========================
package fr.iipt.ka.templates;
import java.io.*;
import java.util.*;
/**
*
Projet : test-templates
Fichier: TestTemplates.java
Package: fr.iipt.ka.templates
@author: Kaesar ALNIJRES
*/
public class TestTemplates {
public static void main(String[] args)
{
List list = new ArrayList();
list.addAll(Arrays.asList(new File(".").listFiles()) );
for (File file : list) {
System.out.println(file.getName());
}
}
}
,${cursor}
Spécifie l'endroit du placement du curseur quand l'édition du template se termine
Template :
==========
//contexte Java
System.out.println("${msg}");
${cursor}
Exemple d'utilisation :
===================
Le curseur est d'abord mis sur " msg " quand l'édition de " msg " est terminé, on valide avec ENTER le curseur passe directement à la ligne suivante
,${date}
Permet d'insérer la date actuelle. Très utile dans Javadoc
Template :
=========
//contexte Javadoc
Date de la création : ${date}
Exemple d'utilisation :
==================
package fr.iipt.ka.templates;
import java.util.*;
import java.io.*;
/**
* @author Kaesar ALNIJRES
* Date de la création : Nov 7, 2008
*/
public class TestTemplates {
private static String c = "Chaine de caractère";
public static void main(String[] args)
{
Calendar maintenant = Calendar.getInstance();
if(maintenant.get(Calendar.YEAR)==2008)
System.out.println("cette année");
}
}
,${id:elemType(variable)}
Le type d'élément d'une variable de template, celle là doit être de type tableau (array) ou java.lang.Iterable.
Note :
Agit de la même manière que argType() seul différence, elle traite aussi le type array.
Template :
==========
//contexte Java
${type:elemType(collection)} ${name} = (${type})${collection}.get(0);
${cursor}
Exemple d'utilisation :
=================
package fr.iipt.ka.templates;
import java.util.*;
import java.util.logging.*;
import java.util.logging.Formatter;
import java.io.*;
/**
*
Projet : test-templates
Fichier: TestTemplates.java
Package: fr.iipt.ka.templates
@author: Kaesar ALNIJRES
*/
public class TestTemplates {
static int i=0;
public static void main(String[] args)
{
List list=new ArrayList();
File name = (File) list.get(0);
}
}
,${enclosing_method}
L'évaluation de cette variable donne le nom de la méthode en-cours.
Template :
=========
//contexte Javadoc
Cette methode est : ${enclosing_method}
Exemple d'utilisation
==================
package fr.iipt.ka.templates;
import java.util.*;
import java.util.logging.Logger;
import java.io.*;
/**
* @author Kaesar ALNIJRES
* Date de la création : Nov 7, 2008 à 9:21:54 PM
*/
public class TestTemplates {
public static void main(String[] args)
{
}
private String lireFichier(File file, String token) {
/**
Cette methode est : lireFichier
*/
String s = null;
return s;
}
}
,${enclosing_method_arguments}
Permet d'insérer les noms des arguments passés à cette méthode séparés par virgule ,
Template :
========
//Contexte Java
${logger}.entering(${enclosing_type}.class.getName(), "${enclosing_method}",new Object[]{${enclosing_method_arguments}});
Exemple : dans logger.enterning()
==============================
package fr.iipt.ka.templates;
import java.io.File;
import java.util.logging.*;
public class EnteringAndExiting {
private static Logger logger = Logger.getLogger("fr.iipt.ka.templates.EnteringAndExiting");
public static void main(String[] args) {
//appler lireFichier()
lireFichier(new File("fichier.txt"),true,1);
}
private static String lireFichier(File fichier,boolean ajouter,int x)
{
//${enclosing_method_arguments} est remplacée par fichier, ajouter, x
logger.entering(EnteringAndExiting.class.getName(), "lireFichier",
new Object[] { fichier, ajouter, x });
return " " ;
}
}
,${enclosing_package} , ${enclosing_project} et ${file}
${enclosing_package}
Cette variable est remplacée par le nom du package contenant la classe ou l'interface, etc.
${enclosing_project}
Cette variable est remplacée par le nom du projet en-cours
${file}
Cette variable est remplacée par le nom du fichier source
Template :
=========
//Contexte Javadoc
Projet : ${enclosing_project}
Fichier: ${file}
Package: ${enclosing_package}
Exemple d'utilisation :
===================
package fr.iipt.ka.templates;
import java.util.*;
import java.util.logging.Logger;
import java.io.*;
/**
*
Projet : test-templates
Fichier: TestTemplates.java
Package: fr.iipt.ka.templates
*/
public class TestTemplates {
public static void main(String[] args)
{
}
}
,${enclosing_type}
Présente le type qui contient le template, par exemple pour une classe le nom de la classe, pour une interface, le nom de l'interface etc.
Template :
=========
//contexte Java
//GetLogger
//after class declaration
${:import(java.util.logging.Logger)}
private static Logger ${logger:var(java.util.logging.Logger)}=Logger.getLogger(${enclosing_type}.class.getName());
Exemple d'utilisation :
==================
package fr.iipt.ka.templates;
import java.util.*;
import java.util.logging.Logger;
import java.io.*;
/**
* @author Kaesar ALNIJRES
* Date de la création : Nov 7, 2008 à 9:21:54 PM
*/
public class TestTemplates {
//GetLogger
//after class declaration
private static Logger logger = Logger.getLogger(TestTemplates.class
.getName());
public static void main(String[] args)
{
}
}
,${exception_variable_name}
Le nom de la variable du bloc " catch "
Template :
========
//contexte Java
try {
${line_selection}${cursor}
} catch (${Exception} ${exception_variable_name}) {
// ${todo}: handle exception
}
Exemple d'utilisation :
==================
package fr.iipt.ka.templates;
import java.io.*;
import java.util.*;
import java.util.logging.*;
/**
*
Projet : test-templates
Fichier: TestTemplates.java
Package: fr.iipt.ka.templates
@author: Kaesar ALNIJRES
*/
public class TestTemplates {
public static void main(String[] args)
{
//in a method
Logger logger = Logger.getLogger(TestTemplates.class.getName());
FileHandler fileHandler = null;
try {
//50000 bytes limit and 3 files (count) for rotation
fileHandler = new FileHandler("%hfileName%g.log", 50000, 3);
//if needed. Defaults XMLFormatter
fileHandler.setFormatter(new SimpleFormatter());
logger.addHandler(fileHandler);
} catch (Exception e) {
// TODO: handle exception
}
}
}
,${variable:field(int)}
Cette variable est évaluée en " membre " visible de type ou de sous types du type (ou types) spécifiés en arguments. Si aucun type n'est spécifié en argument, n'importe quel membre non-primitif.
Template :
=========
//contexte Java
int x = ${variable:field(int)}
Exemple d'utilisation :
===============
package fr.iipt.ka.templates;
import java.util.*;
import java.util.logging.*;
import java.util.logging.Formatter;
import java.io.*;
/**
*
Projet : test-templates
Fichier: TestTemplates.java
Package: fr.iipt.ka.templates
@author: Kaesar ALNIJRES
*/
public class TestTemplates {
static int i=0;
public static void main(String[] args)
{
int x = i;
}
}
,${:import (java.util.logging.Formatter)};
Permet d'importer automatiquement tous les types non déjà importés sauf en cas de conflit d'import
Template :
=========
//contexte Java
$:import(java.util.logging.Logger,java.util.logging.Level,java.util.logging.SimpleFormatter,java.util.logging.XMLFormatter,java.util.logging.Formatter,java.util.logging.ConsoleHandler
)}
Exemple d'utilisation :
=================
package fr.iipt.ka.templates;
import java.util.logging.ConsoleHandler;
import java.util.logging.Formatter;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.logging.SimpleFormatter;
import java.util.logging.XMLFormatter;
/**
*
Projet : test-templates
Fichier: TestTemplates.java
Package: fr.iipt.ka.templates
@author: Kaesar ALNIJRES
*/
public class TestTemplates {
public static void main(String[] args)
{
//in a method
Logger logger = Logger.getLogger(TestTemplates.class.getName());
ConsoleHandler consoleHandler = new ConsoleHandler();
//if needed. Defaults SimpleFormatter
consoleHandler.setFormatter(new SimpleFormatter());
logger.addHandler(consoleHandler);
//set level for logger.Defaults INFO
logger.setLevel(Level.SEVERE);
//set level for ConsoleHandler.Defaults INFO
consoleHandler.setLevel(Level.SEVERE);
}
}
,${:importStatic([qualifiedName[,qualifiedName]*])}
Ajoute une instruction import static pour un membre static, ou méthode, ou un type avec *. En l'absence de conflit et si l'import n'est pas déjà fait. Avec ${:importStatic('java.lang.System.*')} nous avons la possibilité d'utiliser les méthodes et membres statiques (static) de System sans que ceux-ci soit préfixés par " System ". Par exemple au lieu de System.out.println(" msg ") on écrit out.println(" msg ");
Template :
========
//contexte Java
${:importStatic('java.lang.System.*', java.util.logging.Level.INFO)}
out.println("Pas besoin de l\'instruction Complète");
java.util.logging.Logger logger = java.util.logging.Logger.getLogger("nomLogger");
logger.setLevel(INFO);
Note :
Attention aux guillemets simples qui entourent 'java.lang.System.*', et l'espace après le virgule et avant " java.util.logging.Level.INFO "
Exemple d'utilisation :
=================
package fr.iipt.ka.templates;
import static java.lang.System.*;
import static java.util.logging.Level.INFO;
/**
*
Projet : test-templates
Fichier: TestTemplates.java
Package: fr.iipt.ka.templates
@author: Kaesar ALNIJRES
*/
public class TestTemplates {
public static void main(String[] args)
{
out.println("Pas besoin de l\'instruction Complète");
java.util.logging.Logger logger = java.util.logging.Logger
.getLogger("nomLogger");
logger.setLevel(INFO);
}
}
,${index}
Index pour un tableau (array)
Template :
=========
//contexte Java
for (int ${index} = 0; ${index} < ${array}.length; ${index}++) {
${line_selection}${cursor}
}
Exemple d'utilisation :
=================
package fr.iipt.ka.templates;
/**
*
Projet : test-templates
Fichier: TestTemplates.java
Package: fr.iipt.ka.templates
@author: Kaesar ALNIJRES
*/
public class TestTemplates {
public static void main(String[] args)
{
for (int i = 0; i < args.length; i++) {
}
}
}
,${iterable}
Remplacée par un iterable ou un tableau (array)
Template :
=========
//contexte Java
System.out.println(${iterable}.length);
Exemple d'utilisation :
=================
package fr.iipt.ka.templates;
/**
*
Projet : test-templates
Fichier: TestTemplates.java
Package: fr.iipt.ka.templates
@author: Kaesar ALNIJRES
*/
public class TestTemplates {
public static void main(String[] args)
{
String[] chaines={"Hello","World"};
System.out.println(chaines.length);
}
}
,${iterable}
Un nom pour une variable locale pour un élément référencé par ${iterable}
Template :
=========
//contexte Java
for (${iterable_type} ${iterable_element} : ${iterable}) {
${cursor}
}
Exemple d'utilisation :
=================
package fr.iipt.ka.templates;
/**
*
Projet : test-templates
Fichier: TestTemplates.java
Package: fr.iipt.ka.templates
@author: Kaesar ALNIJRES
*/
public class TestTemplates {
public static void main(String[] args)
{
String[] chaines={"Hello","World"};
for (String string : chaines) {
}
}
}
,${iterable_type}
Le type d'élément dans un ${iterable}
Template :
========
//contexte Java
${iterable_type} ${iterable_element} = ${iterable}[0];
${cursor}
Exemple d'utilisation :
=================
package fr.iipt.ka.templates;
/**
*
Projet : test-templates
Fichier: TestTemplates.java
Package: fr.iipt.ka.templates
@author: Kaesar ALNIJRES
*/
public class TestTemplates {
public static void main(String[] args)
{
String[] chaines={"Hello","World"};
String string = chaines[0];
}
}
,${iterator}
Nom inutilisé pour une variable locale de type java.util.Iterator.
Template :
=========
//contexte Java
for (${iteratorType:newType(java.util.Iterator)} ${iterator} = ${collection}.iterator(); ${iterator}.hasNext(); ) {
${type:elemType(collection)} ${name:newName(type)} = (${type}) ${iterator}.next();
${cursor}
}
Exemple d'utilisation :
=================
package fr.iipt.ka.templates;
import java.util.*;
import java.io.*;
import java.util.Iterator;
/**
*
Projet : test-templates
Fichier: TestTemplates.java
Package: fr.iipt.ka.templates
@author: Kaesar ALNIJRES
*/
public class TestTemplates {
public static void main(String[] args)
{
ArrayList list=new ArrayList();
list.addAll(Arrays.asList(new File(".").listFiles()) );
for (Iterator iterator = list.iterator(); iterator.hasNext();) {
File file = (File) iterator.next();
System.out.println("fichier -> "+file.getName());
}
}
}
,${line_selection}
Marque les lignes (dans le source) qui peuvent être entourées par d'autres instructions en provenance d'un template contenant la variable ${line_selection}.
En sélectionnant dans l'éditeur " une ou plusieurs lignes et appliquant un template contenant ${line_selection}, le template va être évalué dans l'éditeur et les lignes sélectionnées vont être insérées à la place de " ${line_selection} "
Note :
La partie sélectionnée doit contenir une ligne complète ou des instructions sur plusieurs lignes.
Note :
Eclipse ne propose que les templates contenant cette variables quand on sélectionne une ou plusieurs lignes suivi de CTRL+ESPACE.
Dans l'exemple suivant, nous voulons uniquement afficher des messages avec un niveau (Level) " Fine " donc dans le fichier source on sélectionne les instructions à logger avec " fine " puis on applique le template. Toutes les instructions sélectionnées sont maintenant à l'intérieur de la condition du template
Template :
========
//contexte Java
if(${logger}.isLoggable(Level.FINE})) {
${line_selection}
}
${cursor}
Exemple d'utilisation :
================
package fr.iipt.ka.templates;
import java.io.File;
import java.util.logging.*;
public class SimpleLogger {
/**
* @param args
*/
private static Logger logger = Logger.getLogger("loggerEntreeSortie");
public static void main(String[] args) {
//sélectionner les deux instructions avant d'appliquer le template
logger.fine("mon niveau est fine");
logger.fine("je suis dans main");
}
}
,${line_selection} suite :
Utile aussi si on souhaite mettre quelques lignes de code dans un commentaire personnalisé
(Commentaire simple et bloc existe déjà dans Eclipse)
Note :
Sélectionner le code à insérer dans le commentaire. Dans l'exemple c'est " System.out.println("cette année"); " -> ALT+SHIFT+Z -> un menu pop-up est affiché et parmi les choix 3 test (nom du template).
Template :
=========
//Java contexte
/*
Ceci est un commentaire perso
${date}
@todo ...
${line_selection}
*/
${cursor}
Exemple d'utilisation :
================
package fr.iipt.ka.templates;
import java.util.*;
import java.io.*;
/**
* @author Kaesar ALNIJRES
* Date de la création : Nov 7, 2008 à 9:21:54 PM
*/
public class TestTemplates {
private static String c = "Chaine de caractère";
public static void main(String[] args)
{
Calendar maintenant = Calendar.getInstance();
if(maintenant.get(Calendar.YEAR)==2008) {
/*
Ceci est un commentaire perso
Nov 8, 2008
@todo ...
System.out.println("cette année");
*/
}
}
}
,${id:link(proposition1,proposition2,proposal]*)}
Cette variable affiche une série de propositions. L'exemple propose de choisir un niveau (parmi plusieurs niveaux) (level) pour tester si le logger peut afficher des messages via son handler.
Template :
=========
//contexte Java
if(${logger:var(java.util.logging.Logger)}.isLoggable(Level.${level:link(SEVERE,WARNING,INFO,CONFIG,FINE,FINER,FINEST)}) )
${logger}.log(Level.${level},"${msg}");
Exemple d'utilisation :
================
package fr.iipt.ka.templates;
import java.util.*;
import java.util.logging.*;
import java.util.logging.Formatter;
import java.io.*;
/**
*
Projet : test-templates
Fichier: TestTemplates.java
Package: fr.iipt.ka.templates
@author: Kaesar ALNIJRES
*/
public class TestTemplates {
static int i=0;
public static void main(String[] args)
{
//in a method
Logger logger = Logger.getLogger(TestTemplates.class.getName());
//log conditional log
// Check if the message will be logged
if (logger.isLoggable(Level.SEVERE))
logger.log(Level.SEVERE, "msg");
}
}
,${newName}
L'évaluation de cette variable donne un nom pour une nouvelle variable locale du type spécifié. Le nom est choisi automatiquement pour éviter un conflit de noms. Dans l'exemple suivant, à la première utilisation du template, la variable donné est " i ", la deuxième fois la variable a pris automatiquement le nom " j ", pour éviter un conflit de noms.
Template :
========
//Contexte Java
int ${i:newName(int)}=0;
${i}=3;
${cursor}
Exemple d'utilisation :
================
/**
test-templates
fr.iipt.ka.templates
SimpleTest.java
Nov 8, 2008:1:56:04 PM
Copyright(c) 2008 Kaesar ALNIJRES
SimpleTest
*
*/
package fr.iipt.ka.templates;
public class SimpleTest {
public static void main(String[] args) {
int i = 0;
i = 3;
int j = 0;
j = 3;
}
}
,${variable:newType(qualifiedTypeName)}
L'évaluation donne un type correspondant au type spécifié en argument. L'évaluation de la variable insère aussi une instruction " import " en absence de conflit, sinon le type inséré est complètement qualifié (fully qualified name).
Template :
=========
//contexte Java
${file:newType(java.io.File)} file=new ${file}("nom");
Exemple d'utilisation :
==================
package fr.iipt.ka.templates;
import java.io.File;
/**
*
Projet : test-templates
Fichier: TestTemplates.java
Package: fr.iipt.ka.templates
@author: Kaesar ALNIJRES
*/
public class TestTemplates {
public static void main(String[] args)
{
File file = new File("nom");
}
}
,${nom} et les variables de l'utilisateur
Les variables de l'utilisateur (qui ne sont pas des variables prédéfinies) sont écrites comme tel dans le code avec la possibilité de les modifier dés l'insertion dans le code source.
Template :
=========
//contexte Java
String nom="${nom}";
System.out.println("Bonjour ${nom}");
et
String nom="${nom}";
System.out.println("Bonjour "+${nom});
Exemple d'utilisation :
================
package fr.iipt.ka.templates;
public class SimpleTest {
public static void main(String[] args) {
String nom = "nom";
System.out.println("Bonjour nom");
}
}
,Les variables de l'utilisateur suite
Les variables de l'utilisateur suite
{ }
Les deux accolades vides désignent un emplacement vide, sans texte. Une position. C'est une variable vide. Quand le curseur est positionné, on peut entrer n'importe quel texte. Si on a plusieurs emplacements vides dans un template, le texte entré est copié d'un emplacement vers les autres automatiquement.
Template :
========
//contexte Java
String ${}1,${}2, ${}3;
Exemple d'utilisation :
================
package fr.iipt.ka.templates;
/**
*
Projet : test-templates
Fichier: TestTemplates.java
Package: fr.iipt.ka.templates
@author: Kaesar ALNIJRES
*/
public class TestTemplates {
public static void main(String[] args)
{
String string1,string2, string3;
}
}
,${primary_type_name}
C'est le type primaire de l'unité de compilation (fichier)
Template :
=========
//contexte Java
System.out.println("Type primaire = ${primary_type_name}");
System.out.println("Enclosing Type = ${enclosing_type}");
System.out.println("Fichier = ${file}");
Exemple d'utilisation :
=================
package fr.iipt.ka.templates;
import java.util.*;
import java.util.logging.*;
import java.util.logging.Formatter;
import java.io.*;
/**
*
Projet : test-templates
Fichier: TestTemplates.java
Package: fr.iipt.ka.templates
@author: Kaesar ALNIJRES
*/
public class TestTemplates {
public static void main(String[] args)
{
System.out.println("Type primaire = TestTemplates");
System.out.println("Enclosing Type = TestTemplates");
System.out.println("Fichier = TestTemplates.java");
}
}
class Test2
{
public Test2()
{
System.out.println("Type primaire = TestTemplates");
System.out.println("Enclosing Type = Test2");
System.out.println("Fichier = TestTemplates.java");
}
}
,${return_type}
Cette variable est évaluée en donnant la valeur de retour d'une méthode
Template :
=========
//contexte Javadoc
Cette mèthode retourne une variable de type : ${return_type}
Exemple d'utilisation :
==================
package fr.iipt.ka.templates;
import java.util.*;
import java.util.logging.*;
import java.util.logging.Formatter;
import java.io.*;
/**
*
Projet : test-templates
Fichier: TestTemplates.java
Package: fr.iipt.ka.templates
@author: Kaesar ALNIJRES
*/
public class TestTemplates {
public static void main(String[] args)
{
System.out.println("Type primaire = TestTemplates");
System.out.println("Enclosing Type = TestTemplates");
System.out.println("Fichier = TestTemplates.java");
}
private String lireFichier(File file, String token) {
/**
* Cette méthode retourne une variable de type : String
*/
String s = null;
return s;
}
}
,${time}
Cette variable est remplacée par l'heure de la machine
Template :
========
//contexte Javadoc
Date de la création : ${date} à ${time}
Exemple d'utilisation :
==================
package fr.iipt.ka.templates;
import java.util.*;
import java.io.*;
/**
* @author Kaesar ALNIJRES
* Date de la création : Nov 7, 2008 à 9:21:54 PM
*/
public class TestTemplates {
private static String c = "Chaine de caractère";
public static void main(String[] args)
{
Calendar maintenant = Calendar.getInstance();
if(maintenant.get(Calendar.YEAR)==2008)
System.out.println("cette année");
}
}
,${variable:localVar(java.lang.String)}
Définir une variable " variable " de type(s) donné en arguments (par exemple String), cette variable va être remplacée par une variable locale ou paramètre visible à l'endroit de l'insertion et de même type ou sous type du type (ou types) défini dans le template. Si aucun type n'est spécifié n'importe quelle variable non primitive. Si plusieurs possibilités, une fenêtre de choix est affichée.
Pour réutiliser cette variable : Il suffit d'entrer ${variable} dans le même template
Note :
Il est possible de spécifier plusieurs type séparés par virgule ','
Object c=${chaine:localVar(java.lang.String, java.lang.Object)};
Template :
========
//contexte Java
String chaine=${chaine:localVar(java.lang.String,java.lang.Object)};
System.out.println(${chaine}.toUpperCase());
Exemple d'utilisation :
================
package fr.iipt.ka.templates;
/**
* @author Kaesar ALNIJRES
*
*/
public class TestTemplates {
private static String c = "Chaine de caractère";
public static void main(String[] args) {
String s = "Bonjour le Monde";
String chaine = s;
System.out.println(s.toUpperCase());
}
}
,${todo}
Cette variable ajoute une instruction TODO pour la tâche en cours
Template :
========
//contexte Java
${todo}Ajouter condition pour chaine vide ???
Exemple d'utilisation :
================
package fr.iipt.ka.templates;
/**
*
Projet : test-templates
Fichier: TestTemplates.java
Package: fr.iipt.ka.templates
@author: Kaesar ALNIJRES
*/
public class TestTemplates {
public static void main(String[] args)
{
String[] chaines={"Hello","World"};
String string = chaines[0];
//TODO Ajouter conditon pour chaine vide ???
}
}
,${variable:var(java.lang.String)}
Définir une variable " variable " de type(s) (par exemple String), cette variable va être remplacée par un membre, variable locale, ou paramètre visible à l'endroit de l'insertion et de même type ou sous type du type défini (ou types) dans le template. Si aucun type n'est spécifié n'importe quelle variable non primitive. Si plusieurs possibilités une fenêtre de choix est affichée.
Note :
Il est possible de spécifier plusieurs types séparés par virgule ','
Object c=${chaine:var(java.lang.String, java.lang.Object)};
Note :
Pour réutiliser cette variable : Il suffit d'entrer ${variable} dans le même template
Template :
========
//contexte Java
String chaine=${chaine:var(java.lang.String)};
System.out.println(${chaine}.toUpperCase());
Exemple d'utilisation :
==================
package fr.iipt.ka.templates;
/**
* @author Kaesar ALNIJRES
*
*/
public class TestTemplates {
private static String c = "Chaine de caractère";
public static void main(String[] args) {
String s = "Bonjour le Monde";
String chaine = s;
System.out.println(s.toUpperCase());
}
}
,Attention les bugs :
Note :
Un petit bug s'est glissé dans les variables et dans le documentation officiel concernant l'utilisation d'un tableau (array) d'objet. En effet il n'est pas possible d'écrire dans un template :
${array:var(java.lang.Object[])} //Erreur
Une solution consiste à entourer l'array avec des guillemets simples
String[] ${chaines:var('java.lang.Object[]')}=tableau_de_chaines; //correct
Exemple d'utilisation :
==================
package fr.iipt.ka.templates;
import java.util.*;
import java.util.logging.*;
import java.util.logging.Formatter;
import java.io.*;
/**
*
Projet : test-templates
Fichier: TestTemplates.java
Package: fr.iipt.ka.templates
@author: Kaesar ALNIJRES
*/
public class TestTemplates {
int i=0;
public static void main(String[] args)
{
String[] tableau_de_chaines={"hello","world"};
String[] chaines = tableau_de_chaines;
}
}
,${user}
Le nom de l'utilisateur. Utile dans Javadoc pour insérer l'auteur
Template :
========
//contexte Javadoc
@author ${user}
Important :
La variable ${user} est remplacée dans le code par l'utilisateur de la machine (nom utilisateur). Parmi les solutions à ce problème est d'insérer l'option suivante dans le fichier " eclipse.ini " dans le dossier d'installation d'Eclipse, à la fin du fichier comme suite :
-startup
plugins/org.eclipse.equinox.launcher_1.0.200.v20080825-1800.jar
--launcher.library
plugins/org.eclipse.equinox.launcher.gtk.linux.x86_64_1.0.200.v20080731-1700
-showsplash
org.eclipse.platform
--launcher.XXMaxPermSize
256m
-vm
/divers0/jdk/jdk1.6.0_10_x86_64/bin
-vmargs
-Xms400m
-Xmx2560m
-Duser.name="Kaesar ALNIJRES"
Exemple d'utilisation :
==================
/**
Date de la création : Nov 8, 2008 à 1:27:34 PM
@author "Kaesar ALNIJRES"
*/
package fr.iipt.ka.templates;
public class tt extends SimpleLogger {
}
,${word_selection}
Marquer un mot dans le source pouvant être entouré par d'autres instructions en provenance d'un template contenant la variable ${word_selection}.
En sélectionnant dans l'éditeur un mot puis CTRL+ESPACE. Des templates contenant
${word_selection} sont proposés, le template sélectionné est évalué, les instructions dans le template entourent le mot sélectionné dans l'éditeur qui remplace la variable
${word_selection} dans le template.
En sélectionnant dans l'exemple le mot " fine " ou une autre méthode de Logger, on peut insérer une instruction de log en utilisant la méthode fine,severe,info ou autre de Logger.
Note :
${word_selection} agit au niveau d'un mot à la manière de ${line_selection} pour les lignes.
Template :
=========
//Contexte Java
//output simple message
${logger:var(java.util.logging.Logger)}.${word_selection}("${msg}");
${cursor}
Exemple d'utilisation :
==================
package fr.iipt.ka.templates;
import java.util.*;
import java.util.logging.*;
import java.io.*;
/**
*
Projet : test-templates
Fichier: TestTemplates.java
Package: fr.iipt.ka.templates
@author: Kaesar ALNIJRES
*/
public class TestTemplates {
public static void main(String[] args)
{
Logger logger = Logger.getLogger(TestTemplates.class.getName());
//output simple message
logger.info("msg");
}
}
,${year}
Permet d'insérer automatiquement l'année en cours. Utile par exemple, pour insérer une notice de copyright dans Javadoc. Il est possible de l'utiliser aussi dans des instructions Java.
Templates :
=========
//Contexte Javadoc
Copyright ${year}
------------------------------
//Contexte Java
Calendar maintenant = Calendar.getInstance();
if(maintenant.get(Calendar.YEAR)==${year}
Exemple d'utilisation :
================
package fr.iipt.ka.templates;
import java.util.*;
import java.io.*;
/**
* @author Kaesar ALNIJRES
*
*/
public class TestTemplates {
public static void main(String[] args)
{
Calendar maintenant = Calendar.getInstance();
if(maintenant.get(Calendar.YEAR)==2008)
System.out.println("cette année");
}
}
,Rectification
Une erreur s'est glissé dans ce tutoriel à l'étape 32 :
32.${iterable} doit être remplacée par ${iterable_element}
,Conclusion :
Ce système de templates est très efficace pour économiser le temps et supprimer une quantité importante de frappe répétitive. L'avantage des templates de l'éditeur est de pouvoir agir directement au niveau de l'éditeur sans passer par les développements de plug-ins.
,Sites :
http://www.eclipseplugincentral.com/Web_Links-index-req-viewlink-cid-1358.html
Ajouter un commentaire