© Copyright Azzurri Ltd. 2003-2005. All rights reserved.
 Eclipse-artikel

JET-øveprogram del 1 (Introduktion til JET)

Oversigt

Generering af kildekode kan spare tid i dine projekter og mindske omfanget af trættende programmering af gentagelser. Generering af kildekode kan være effektivt, men det program, der skriver koden, kan hurtigt blive meget komplekst og svært at forstå. Kompleksiteten kan mindskes, og læsbarheden kan forbedres ved at bruge skabeloner.

Projektet Eclipse Modeling Framework (EMF) indeholder to meget effektive værktøjer til generering af kildekode: JET (Java Emitter Templates) og JMerge (Java Merge). Med JET kan du bruge en JSP-lignende syntaks (faktisk en delmængde af JSP-syntaksen), der gør det let at skrive skabeloner, som udtrykker den kode, du vil generere. JET er en generisk skabelongenerator, der kan bruges til at generere SQL-, XML- og Java-kildekode og andet output fra skabeloner. JET er placeret i plugin'en org.eclipse.emf.codegen som en del af overførslen af EMF Runtime.

I denne artikel beskrives, hvordan du kan oprette JET-skabeloner, bruge JET-naturen og JET-byggeprogrammet til automatisk at omdanne skabeloner til Java-klasser, og hvordan du kan bruge disse klasser til at generere kildekode. Artiklen indeholder også en kort oversigt over JET-syntaksen.

Bidragyder: Remko Popma, Azzurri Ltd., remko.popma snabel-a azzurri punktum jp, 30. juli 2003. Bruges med tilladelse. Sidst opdateret: 3. januar 2007.


Indhold

Kom godt i gang
JET-modellen
Direktiver
JET-scriptelementer
Ressourcer

Kom godt i gang

Før vi kan oprette den første skabelon, har du brug for EMF-plugin'en. Hvis du endnu ikke har installeret den, skal du installere den nu, før du fortsætter med øveprogrammet.

Skærmbillederne er fra version 3.1.0 RC2 af Eclipse SDK og version 2.1.0 I200506160200 af EMF. Brug af Java 5.0-konstruktioner, f.eks. generiske typer, er dog mindst Eclipse 3.3M4 og EMF 2.3.0M4.

En JET-skabelon er en tekstfil med et filnavn, som slutter med "jet". Vi følger EMF-konventionen med at tilføje "jet" til den genererede kodes filtype, så .javajet betyder, at skabelonen genererer en .java-fil, .xmljet, at skabelonen genererer XML, mens skabeloner, som genererer SQL, har filtypen .sqljet osv.

JET-natur og JET-byggeprogram

Vi følger traditionen og begynder med en skabelon, der opretter meddelelsen "Hello, world". Vi opretter vores første skabelon ved at bruge følgende fremgangsmåde i fire trin:

  1. Opret et nyt Java-projekt, og tildel kildefolderen "src" til det
  2. Tilføj JET-naturen til projektet. Derved oprettes en folder ved navn "templates" under projektroden.
  3. Revidér projektets JET-egenskaber for at sikre, at skabeloner dannes i kildefolderen "src" for projektet
  4. Opret en ny fil ved navn "helloworld.txtjet", og gem den i folderen templates

Trin 1. Opret et projekt

Vælg Fil > Ny > Projekt på menuen i arbejdsbænken for at åbne guiden Nyt projekt. Opret et nyt Java-projekt, og tilføj en kildefolder ved navn src til det.

Nyt Java-projekt med folderen src

Trin 2. Konvertér projektet til et JET-projekt

Når du har oprettet projektet, skal du højreklikke på det i Package Explorer eller oversigten Hierarki og vælge Ny > Andet > Java Emitter-skabeloner > Konvertér projekter til JET-projekter.

Nyt Java-projekt med folderen src

Tryk på knappen Næste, vælg det projekt, du har oprettet, og klik på Afslut.

Tilføj JET-natur til Java-projekt

Guiden opretter JET-naturen til projektet ved at oprette folderen templates under projektroden som vist på billedet herunder. Desuden tilføjes et JET-byggeprogram til projektet, som automatisk omdanner alle filer i folderen templates med et filnavn, der slutter med "jet", til en Java-klasse.

Folderen Templates oprettet

Trin 3. Revidér JET-indstillinger

Før vi opretter vores første skabelon, kontrollerer vi, at projektets kildefolder src er destinationsfolderen for de omdannede skabeloner. Højreklik på projektet, og vælg "Egenskaber" på pop op-menuen. Vælg JET-indstillinger på menuen til venstre i dialogboksen Projektegenskaber, og indtast "src" (navnet på kildefolderen) i tekstfeltet "Kildeopbevaringssted". På billedet herunder vises egenskabssiden JET-indstillinger i dialogboksen Projektegenskaber.

Tilføj folder til kildeopbevaringssted

Tip: Bemærk, at du kan angive flere foldere i feltet Skabelonopbevaring adskilt med et mellemrum eller et semikolon. Hvis skabeloner i forskellige foldere har samme filnavn, omdannes kun skabelonen i den første folder automatisk af JET-byggeprogrammet. Hvis alle skabeloner skal omdannes, skal du sørge for, at de har forskellige filnavne.

Trin 4. Opret en JET-skabelonfil

JET-byggeprogrammet omdanner nu alle skabeloner til Java-kildefiler i projektets src-folder.

Deaktivér først automatisk bygning for at undgå problemer under bygningen. Fjern markeringen af "Byg automatisk" på menuen Projekt.

Menuen Projekt med punkterne Byg alle og Byg automatisk

Nu skal vi oprette den første skabelon. Vælg Fil > Ny > Fil på menuen i arbejdsbænken for at åbne guiden Ny fil. Vælg biblioteket templates som den overordnede folder, og kald filen helloworld.txtjet.

Opret tom helloworld.txtjet-fil

Når "Byg automatisk" er deaktiveret, får du ikke følgende fejl, når du klikker på knappen Afslut: "Direktivet 'jet' mangler i 'helloworld.txtjet' linje 1 kolonne 1" som vist på billedet herunder.

Fejl under udførelse af JET-byggeprogram på tom .txtjet-fil

Hvis Automatisk bygning er aktiveret, får du vist ovenstående fejlmeddelelse. Det betyder heldigvis ikke, at der er et rigtigt problem, blot at JET-byggeprogrammet forsøgte at omdanne vores skabelon, så snart vi havde oprettet den, og opdagede, at den stadig er tom. Klik på OK for at lukke dialogboksen med fejlen. Åbn filen helloworld.txtjet, hvis den ikke er åben, og skriv eller kopiér og indsæt følgende indhold i editoren.

 <%@ jet package="hello" class="HelloWorldTemplate" %>

 Hello, world!

Når du gemmer skabelonfilen, omdannes den automatisk af JET-byggeprogrammet, hvis "Byg automatisk" er markeret. Hvis det ikke sker, skal du vælge "Byg projekt" på menuen Projekt.

Eftersom vi angav pakken hello og klassen HelloWorldTemplate på første linje i skabelonen, opretter byggeprogrammet pakken hello i folderen src og gemmer en Java-fil ved navn HelloWorldTemplate.java i denne pakke som vist på billedet nedenfor.

Pakken hello indeholder nu klassefilen HelloWorldTemplate.java

Denne Java-klasse er resultatet af omdannelsen af skabelonen og kaldes en skabelonimplementeringsklasse. Klassen har en metode ved navn generate. Det er den metode, som genererer den kode, der er angivet i skabelonen.

Prøv det!Vi kan oprette en forekomst af skabelonimplementeringsklassen HelloWorldTemplate og kalde dens generate-metode på denne måde:

Opret en ny klasse ved navn HelloWorldImpl for at implementere ovenstående. Højreklik på pakken hello i Package Explorer eller oversigten Hierarki, og vælg Ny > Klasse.

Opret ny klasse

Giv klassen navnet "HelloWorldImpl", og sørg for, at stubben void main(String[] args) er markeret.

Opret ny HelloWorldImpl-klasse med main-metodestub

Kopiér nu følgende kode til metoden main():

 HelloWorldTemplate helloworld = new HelloWorldTemplate();
 String result = helloworld.generate(null);
 System.out.println(result);

Klassen HelloWorldImpl med eksempel på main-metode

Udfør den ved at vælge "Udfør som/Java-program" på menuen Udfør på værktøjslinjen. Du skulle nu se ordene "Hello, world!" udskrevet på konsollen.

Overfør argumenter til skabelonen

For at opsummere har vi netop oprettet vores første skabelon og genereret noget kode med den. Resultatet er måske ikke imponerende, men vi er nu klar til at udforske det, som JET kan gøre for dig. Det næste trin består i at overføre et argument til skabelonen.

Prøv det!Tilføj en ny JET-skabelonfil, eller ret den eksisterende, så den har følgende indhold:


 <%@ jet package="hello" class="GreetingTemplate" %>
 Hello, <%=argument%>!

JET-byggeprogrammet omdanner skabelonen til klassen GreetingTemplate i pakken hello. Vi opretter igen en forekomst af denne skabelon (eller ændrer den eksisterende HelloWorldImpl), men denne gang overfører vi et strengargument til metoden generate:

 GreetingTemplate sayHello = new GreetingTemplate();
 String result = sayHello.generate("Tutorial Reader");
 System.out.println(result);

Ovenstående kode vil udskrive ordene "Hello, Tutorial Reader!" på konsollen.

Importér pakker

Det argument, du overfører til en skabelon, kan være et hvilket som helst objekt. I det foregående eksempel overførte vi en streng som argument til metoden generate, men i dit program vil du nok overføre dit eget modelobjekt. Hvis argumentet ikke findes i pakken java.lang, eller hvis din skabelon bruger andre klasser, som ikke er indeholdt i pakken java.lang, skal du importere disse klasser i skabelonens jet-direktiv. Et jet-direktiv med attributten Kode 1imports ser sådan ud:

 <%@ jet package="hello" Kode 1imports="java.util.*" class="ImportDemoTemplate" %>

I afsnittet JET-syntaksoversigt i denne artikel findes flere oplysninger om direktivet jet og dets attributter.

I næste eksempel vil vi oprette en skabelon, der genererer XML-kode. For at følge EMF-konventionen med at tilføje "jet" til den genererede kodes filtype gemmer vi denne skabelon i en fil ved navn importdemo.xmljet. Bemærk, at vi overfører objektet java.util.List til skabelonen. Det indeholder de data, der skal bruges under generering af XML-koden.

   <%@ jet package="hello" Kode 1imports="java.util.*" class="XMLDemoTemplate" %>

Kode 2<% List<?> elementList = (List<?>) argument; %>
   <?xml version="1.0" encoding="UTF-8"?>
   <demo>
   <% for (Iterator<?> i = elementList.iterator(); i.hasNext(); ) { %>
     <element><%=i.next().toString()%></element>
   <% } %>
   </demo>

Koden nedenfor viser, hvordan vi starter skabelonforekomsten. Vi opretter en Kode 2liste og Kode 3overfører den til metoden generate for skabelonimplementeringsklassen:

package hello;

import java.util.ArrayList;

public class XMLDemoImpl {
  public static void main(String[] args) {
    Kode 2List<String> data = new ArrayList<String>();
    data.add("first");
    data.add("second");
    data.add("third");

    XMLDemoTemplate generateXml = new XMLDemoTemplate();
    String result = generateXml.generate(Kode 3data);
    System.out.println(result);
  }
}

Det udskriver følgende XML-resultat på konsollen:

 <?xml version="1.0" encoding="UTF-8"?>
 <demo>
   <element>first</element>
   <element>second</element>
   <element>third</element>
 </demo>

Det er et meget simpelt eksempel, der opretter meget simpel XML. Du kan selvfølgelig bruge JET til at oprette mere kompleks XML med brug af attributter og navneområder. Når du gør det, vil du måske finde det mere praktisk at oprette en særlig klasse, som er en bedre model af et XML-dokument end java.util.ArrayList. Generelt gælder, at jo mere kompleks din JET-skabelon bliver, desto mere logik vil du skubbe ind i det modelobjekt, du overfører til skabelonen, så skabelonerne stadig er læsevenlige. Det ser vi nærmere på i del 2 af dette øveprogram.

Revidér koder

En smart funktion i JET er, at du kan ændre de koder, som markerer minikommandofiler (scriptlets) i skabelonfilen. Det er meget praktisk, når syntaksen for den kode, du genererer, er meget lig JET-standardsyntaksen, f.eks. hvis du bruger JET til at generere JSP-sider.

I næste eksempel vil vi bruge JET til at generere en enkel JSP-side. Vi vil ændre JET-koderne, så tegnsekvensen "<$" bruges til at indlede en skabelonkode, og "$>" bruges til at afslutte en skabelonkode. Skabelonen indeholder stadig strengene "<%" og "%>", men JET-programmet opfatter dem ikke længere som specielle, og de vil blive skrevet til resultatet som enhver anden tegnsekvens.

Prøv det!Revidér kodemarkeringerne ved at tilføje attributterne Kode 1startTag og Kode 2endTag til JET-direktivet på første linje i skabelonen som i eksemplet nedenfor.

 <%@ jet package="tags.demo" class="JspTemplate" Kode 1startTag="<$" Kode 2endTag="$>" %>

 <$ String paramName = (String) argument; /* This is an executed scriptlet */ $>
 <$ if (paramName != null) { $>
 Kode 3  <%= request.getParameter("<$=paramName$>") %> <!-- this is generated JSP -->

 <$ } $>

Som før kalder vi denne implementeringsklasse med et strengargument:

 System.out.println(new tags.demo.JspTemplate().generate("button"));
Følgende output vises på konsollen. Bemærk, at outputtet indeholder den intakte JSP-kode: Tegnstrengene "<%" og "%>" fortolkes ikke som en JET-minikommandofil, men indsættes blot i den genererede kode.
 Kode 3  <%= request.getParameter("button") %> <!-- this is generated JSP -->

Bag kulisserne

I det foregående afsnit beskrev vi oprettelse af JET-skabeloner, opsætning af JET-naturen, så den automatisk omdanner skabeloner til Java-implementeringsklasser, og hvordan disse Java-implementeringsklasser bruges til at generere kode.

I dette afsnit ser vi nærmere på de Java-implementeringsklasser, der er resultatet af omdannelse af en skabelon. Vi vil se på, hvorfor vi kan bruge de implicitte objekter argument og stringBuffer i en skabelon og også se på tilpasning af den omdannede implementeringsklasse ved hjælp af et tilpasset "skelet".

Omdannede skabeloner

En JET-skabelon omdannes til en Java-implementeringsklasse. Der er nogle objekter i Java-implementeringsklassen, der kan refereres direkte til i JET-skabelonen. Følgende eksempel viser, hvordan de implicitte objekter argument og stringBuffer kan bruges i en skabelon.

 <%@ jet package="hello" class="TranslationDemoTemplate" %>

Kode 1 Hello, <%=argument%>!
Kode 2 <% stringBuffer.append("Hello again!"); %>

Skabelonen ovenfor omdannes til en Java-implementeringsklasse som her:

 package hello;

 public class TranslationDemoTemplate
 {
   protected static String nl;
Kode 3 public static synchronized TranslationDemoTemplate create(String lineSeparator)
   {
     nl = lineSeparator;
     TranslationDemoTemplate result = new TranslationDemoTemplate();
     nl = null;
     return result;
   }

   protected final String NL = nl == null ? (System.getProperties().getProperty("line.separator")) : nl;
   protected final String TEXT_1 = "Hello, ";
   protected final String TEXT_2 = "!";

   public String generate(Object argument)
   {
     StringBuffer stringBuffer = new StringBuffer();
     stringBuffer.append(TEXT_1);
Kode 1  stringBuffer.append(argument);
     stringBuffer.append(TEXT_2);

Kode 2  stringBuffer.append("Hello again!");
     return stringBuffer.toString();
   }
 }

Bemærk, at metoden generate for Java-implementeringsklassen skal have en Object-parameter ved navn argument. Det er samme objekt som Kode 1argument på anden linje i skabelonen. Bemærk også, hvordan Java-implementeringsklassen benytter et StringBuffer-objekt til at indsamle den genererede resultatkode. Der kan Kode 2refereres direkte til dette objekt i skabelonen med dets navn, stringBuffer.

Den statiske metode Kode 3create sætter et program i stand til at oprette en forekomst af TranslationDemoTemplate, som bruger en bestemt streng som linjeskilletegn.

Revidér skelettet til den omdannede implementeringsklasse

Metoden generate for klassen TranslationDemoTemplate ovenfor siges at være en del af implementeringsklassens "skelet". Det standardskelet, som bruges af JET-programmet, ser sådan ud:

 public class CLASS
 {
   public String generate(Object argument)
   {
     return "";
   }
 }

Skeletdefinitionen ser næsten ud som en normal Java-klasse, bortset fra klassenavnet. Klassenavnet (CLASS) vil blive erstattet af værdien af attributten class i direktivet jet. Desuden har skeletdefinitionen den generate-metode, vi så tidligere. Ved at ændre skelettet kan du tilpasse en implementeringsklasse, f.eks. få den til at implementere en grænseflade eller ændre en anden egenskab ved klassen.

Prøv det!Antag f.eks., at du vil have alle dine skabelonimplementeringsklasser til at implementere en grænseflade. Grænsefladen kan se sådan ud:

 public interface IGenerator {
     String generate(Object argument);
 }

Vi kan informere JET-programmet om, at vi vil bruge et tilpasset skelet, ved at angive attributten skeleton for jet-direktivet på første linje i skabelonfilen. Værdien af attributten skeleton er en URI, der peger på en fil, som indeholder definitionen af det tilpassede skelet.

Hvis du vil prøve dette, skal du først oprette en ny Tekstfil uden titel fra menuen Fil > Ny eller værktøjslinjen.

Opret ny Tekstfil uden titel fra menuen Fil - Ny

Indtast eller kopiér og indsæt følgende indhold i den:

 public class CLASS Kode 1implements IGenerator
 {
Kode 2/* (non-javadoc)
    * @see IGenerator#generate(Object)
    */
Kode 3public String generate(Object argument)
   {
     return "";
   }
 }

Gem nu filen som generator.skeleton i biblioteket templates som på billedet herunder.

Tekstfilen generator.skeleton i folderen templates

Denne fil er vores tilpassede skelet. Alle skabeloner, som benytter dette skelet, vil blive omdannet til klasser, der implementerer grænsefladen IGenerator. Når du vil bruge skelettet, skal du tilføje attributten skeleton til jet-direktivet for din skabelon på denne måde:

 <%@ jet package="hello" class="GreetingTemplate" skeleton="generator.skeleton" %>
 Hello, <%=argument%>!
 The current time is <%=new java.util.Date()%>.

Når JET-byggeprogrammet har omdannet skabelonen, ser implementeringsklassen sådan ud:

 package hello;

 public class GreetingTemplate Kode 1implements IGenerator
 {
   protected final String NL = System.getProperties().getProperty("line.separator");
   protected final String TEXT_1 = "Hello, ";
   protected final String TEXT_2 = "!" + NL + "The current time is ";
   protected final String TEXT_3 = ".";
   protected final String TEXT_4 = NL;


Kode 2/* (non-javadoc)
    * @see IGenerator#generate(Object)
    */
Kode 3public String generate(Object argument)
   {
     StringBuffer stringBuffer = new StringBuffer();
     stringBuffer.append(TEXT_1);
     stringBuffer.append(argument);
     stringBuffer.append(TEXT_2);
     stringBuffer.append(new java.util.Date());
     stringBuffer.append(TEXT_3);
     stringBuffer.append(TEXT_4);
     return stringBuffer.toString();
   }
 }

Bemærk, at den omdannede skabelon nu Kode 1implementerer grænsefladen IGenerator, og at metoden Kode 3generate nu har Kode 2de kommentarer, som vi angav i filen generator.skeleton. Det er et eksempel på, hvordan en omdannet skabelon tilpasses med en skeletdefinition. Skeletdefinitioner kan også indeholde ekstra metoder, indre klasser osv. Du kan eksperimentere lidt for at se, hvad der ellers kan lade sig gøre.

JET-syntaksoversigt

Hvis du har brugt JSP-teknologi tidligere, ser JET-syntaksen nok meget bekendt ud. JET-syntaksen er en delmængde af JSP-syntaksen, så der er måske ikke så meget nyt her for dig.

Dette afsnit indeholder en uformel beskrivelse af og oversigt over JET-syntaksen.

JET-modellen

En JET-skabelon omdannes til en Java-implementeringsklasse. Denne implementeringsklasse har en metode, der kan kaldes for at hente en resultatstreng. Metoden kaldes normalt generate (se også attributten skeleton for direktivet jet).

Hvis der ikke angives en skeleton-attribut i direktivet jet, har Java-implementeringsklassen følgende underforståede objekter, der kan refereres til i JET-skabelonen:

Direktiver

Direktiver er meddelelser til JET-programmet. Direktiver har denne syntaks:

<%@ direktiv { attr="værdi" }* %>

Der kan være mere tom plads efter "<%@" og før "%>".

Direktiver påvirker den måde, en skabelon omdannes på, men de producerer ikke noget output i den genererede streng, når skabelonen kaldes.

Direktivet jet

Direktivet jet definerer et antal attributter og formidler dem til JET-programmet. En JET-skabelonfil skal indeholde direktivet jet på første linje i filen. Ellers kan skabelonfilen ikke omdannes. Efterfølgende jet-direktiver ignoreres. Ukendte attributter medfører uoprettelige fejl under omdannelsen.

Følgende direktiv angiver, at skabelonen skal omdannes til en Java-implementeringsklasse ved navn HelloWorldTemplate.java i pakken hello. Implementeringsklassen skal importere pakkerne java.io.* og java.util.*.

 <%@ jet package="hello" class="HelloWorldTemplate" imports="java.io.* java.util.*" %>

Her er flere oplysninger om attributterne for direktivet jet:

Attribut Værdi
package Pakkenavnet på den Java-implementeringsklasse, som skabelonen omdannes til. Hvis attributten ikke er angivet, oprettes Java-implementeringsklassen i standardpakken.
class Navnet på den Java-implementeringsklasse, som skabelonen omdannes til. Hvis den ikke er angivet, kaldes Java-implementeringsklassen for CLASS.
imports En liste med pakker og/eller klasser adskilt med mellemrum, som skal importeres i Java-skabelonklassen.
startTag Den streng i en JET-skabelon, der markerer starten på en minikommandofil (scriptlet), et udtryk eller direktivet include. Standardværdien er "<%". Attributten og dens partner, endTag, kan være meget praktiske, når den genererede kodes syntaks ligner JET-standardsyntaksen, f.eks. hvis du bruger JET til at generere JSP-sider.
endTag Den streng i en JET-skabelon, der markerer slutningen på en minikommandofil (scriptlet), et udtryk eller direktivet include. Standardværdien er "%>". Se også startTag.
skeleton URI'en for en fil med en skeletdefinition af den Java-implementeringsklasse, som skabelonen omdannes til. URI'en fortolkes i lighed med den måde, som værdien for attributten file fortolkes på i et include-direktiv. Hvis der ikke angives en skeletdefinitionsfil, bruger JET-programmet et standardskelet i formatet "public class CLASS\n{\n public String generate(Object argument)\n {\n return \"\";\n }\n}\n". Klassenavnet i denne skeletklassedefinition skal være CLASS.
nlStreng Den streng for Ny linje, der skal bruges i Java-skabelonklassen. Standardværdien er "System.getProperties().getProperty(\"line.separator\")"

Direktivet include

Direktivet include bruges til at erstatte tekst og/eller kode under omdannelsen af skabelonen. Direktivet <%@ include file="urlSpec" %> indsætter tekst fra den angivne ressource i JET-skabelonfilen. Inkluderingsfilen kan have JET-scriptelementer, som også vil blive behandlet.

Direktivet har en enkelt attribut - file. Værdien af attributten er URI'en for placeringen af den fil, der skal inkluderes. URI'en kan enten være en absolut sti eller en relativ sti. Relative URI'er fortolkes altid som relative i forhold til folderen med den skabelon, som indeholder direktivet include.

Eksempel:

I følgende eksempel anmodes om inkludering af en copyrightfil på omdannelsestidspunktet.

 <%@ include file="copyright.jet" %>

Tip: Bemærk, at JET understøtter begrebet med tilsidesættende skabelonstier. Det er muligt at konfigurere JET, så JET bruger flere skabelonopbevaringssteder. I det tilfælde har det første opbevaringssted forrang frem for det andet, det andet frem for det tredje osv. Det betyder, at hvis der findes skabelonfiler eller inkluderingsfiler med samme filnavn i flere skabelonopbevaringssteder, anvendes filen i første folder, og den eller de øvrige ignoreres. Klienter for et JET-baseret program kan bruge denne mekanisme til at angive inkluderingsfiler, der tilsidesætter de oprindelige inkluderingsfiler, uden at ændre det oprindelige programs skabeloner.

JET-scriptelementer

JET har to scriptsprogselementer: minikommandofiler (scriptlets) og udtryk. En minikommandofil er et sætningsfragment, og et udtryk er et komplet Java-udtryk.

Hvert scriptelement har en "<%"-baseret syntaks:

 <% dette er en minikommandofil %>
 <%= dette er et udtryk %>

Tom plads er valgfrit efter "<%" og "<%=" og før "%>".

Hvis du vil bruge %>-tegnsekvensen som en strengværdi i en minikommandofil, kan du gøre det ved at skrive %\> frem for at afslutte minikommandofilen. På samme måde kan du bruge <%-tegnsekvensen som en strengværdi ved at skrive <\%.

Minikommandofiler

Minikommandofiler kan indeholde et hvilket som helst gyldigt Java-kodefragment.

Minikommandofiler udføres, når skabelonen kaldes. Om de producerer output i resultatstrengen afhænger af den faktiske kode i minikommandofilerne. Minikommandofiler kan have afledte virkninger, idet de kan ændre de objekter, der er synlige i dem.

Når alle minikommandofilfragmenter i en given omdannelsesenhed er kombineret i den rækkefølge, de har i JET-skabelonen, skal de udgøre en eller flere gyldige Java-sætninger.

Eksempel:
 <% if (Calendar.getInstance().get(Calendar.AM_PM) == Calendar.AM) {%>
 Good Morning
 <% } else { %>
 Good Afternoon
 <% } %>

Syntaks

<% minikommandofil %>

Udtryk

Et JET-udtrykselement er et Java-udtryk, der evalueres, hvorefter resultatet tilføjes til det StringBuffer-objekt, der returneres af metoden generate. Udtryk evalueres, når skabelonen kaldes.

Hvis resultatet af udtrykket ikke kan tilføjes til StringBuffer, opstår en fejl på omdannelsestidspunktet. Indholdet i et JET-udtryk skal være et komplet Java-udtryk.

Afledte virkninger i udtryk understøttes. De træder i kraft, når JET-udtrykket evalueres. JET-udtryk evalueres fra venstre mod højre i JET-skabelonen.

I næste eksempel tilføjes dags dato til StringBuffer-resultatet.

<%= (new java.util.Date()).toLocaleString() %> 

Syntaks

<%= udtryk %>

Ressourcer

http://www.javaworld.com/javaworld/jw-11-2001/jw-1102-codegen.html

http://www.eclipse.org/emf/