Eclipse et les templates Java par l'exemple

Par :
ka
mer, 12/11/2008 - 11:23
Niveau :
Facile

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

  1. Nom du template, le nom permet d'appeler le template

  2. Description, très important permettant de distinguer plusieurs templates portant le même nom

  3. Contexte du template. Dans quel contexte ce template doit être proposé et quelles sont les variables prédéfinies disponibles dans ce contexte.

  4. Insertion automatique (si un template unique)

  5. Pattern : le corps du template

  6. 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://help.eclipse.org/

http://www.eclipse.org

http://www.eclipseplugincentral.com/Web_Links-index-req-viewlink-cid-1358.html

Ajouter un commentaire

Filtered HTML

Plain text

CAPTCHA
Cette question permet de vérifier que vous n'êtes pas un robot spammeur :-)
 RRRR   BBBB   TTTTTT  EEEE  III 
R R B B TT E I
RRRR BBBB TT EEE I
R R B B TT E I
R RR BBBB TT EEEE III