Představte si situaci, kdy ve vaší účetní aplikaci
                  pracujete s třídou ucto.faktura,
                  definovanou v Javě třeba takto:
package ucto;
                  
                  // vystavene faktury 
                  public class faktura {
public String
                  cislo_faktury;
                  public Date datum_vystaveni;
                  public ArrayList<polozka> polozky; // reference
                  na tridu ucto.polozka
                  public String prijemce;
                  public Boolean vystavena;
                  public Date splatno_ke_dni;
                  public Boolean splaceno;
                  public Float castka; 
                  }
S touto třídou ve své aplikaci budete chtít
                  manipulovat následujícím způsobem:
- Vytvářet nové faktury a vystavovat je
- Ukládat faktury do databáze a prohlížet si
 jejich obsah
- Provádět dotazy nad fakturami za nějakou část
 účetního období, např. sledovat saldo mezi
 přijatými a vystavenými fakturami, nebo hledat
 faktury po době splatnosti, a to prostřednictvím
 oblíbeného reportovacího nástroje pracujícího s
 SQL.
                K tomu, aby se naše Java třídy „naučily“ ukládat data
                do databáze Caché nám stačí provést jen několik málo
                kroků.
- K již vytvořeným Java třídám přidáme anotace,
 které budou Caché poskytovat informace o třídě
 samotné a další informace, např. o indexech které
 se mají vytvářet atd…
- Spustíme importovací utilitu, která k vybraným
 Java třídám vytvoří v Caché odpovídající
 persistentní třídy.
- V aplikaci budeme používat API Jalapeno runtime
 knihoven k manipulaci s daty uloženými v Caché.
Pojďme se nejdříve podívat na anotace Caché.
V Java J2EE verzi 1.5 byl zaveden nový prvek –
                  anotace. Syntakticky vycházejí z javadoc značek a
                  nemají vliv na samotný Java kód, ale mohou velice
                  významným způsobem ovlivňovat způsob práce různých
                  nástrojů a knihoven. Na rozdíl on jiných API, jako
                  např. EJB, nevyžadují externí soubory tuto interakci
                  popisující, ale jsou součástí samotného Java kódu.
Caché implementuje různé anotace, které lze v
                  zásadě členit na anotace na úrovni třídy a anotace na
                  úrovni vlastností.
Příkladem anotace na úrovni třídy je např. @CacheClass() nebo @Index(),
                  příkladem anotace na úrovni vlastnosti je @CacheProperty().
Každá anotace obsahuje různě dlouhý seznam atributů
                  určujících chování kompilátoru Caché.
Např. @CacheClass(name=”ucto.faktura”, říká kompilátoru Caché,
                  xmlSerializable=true)
                  že vytvořená třída bude nazvána „ucto.faktura“, bude
                  persistentní (výchozí hodnota, není nutno
                  specifikovat) a bude obsahovat XML schopnosti – ty
                  jsou v Caché získány poděděním od třídy %XML.Adaptor.
                
package ucto; 
                  import com.intersys.pojo.annotations.*;
                  
                  // vystavene faktury 
                  @CacheClass(name=”ucto.faktura”,
                  xmlSerializable=true) 
                  public class faktura { 
public String
                  cislo_faktury;
                  public Date datum_vystaveni;
                  public ArrayList<polozka> polozky; // reference
                  na tridu ucto.polozka
                  ... 
                  }
Definice vygenerované Caché třídy bude tedy vypadat
                  takto:
Class ucto.faktura extends (%Persistent,
                  %XML.Adaptor) { … tělo třídy … } 
Řekněme, že pro účely rychlého vyhledávání podle
                  čísla faktury budeme chtít, aby Caché vytvořila nad
                  vlastností cislo_faktury index.
                  Zároveň, protože Caché nedovolí použít podtržítko v
                  názvech tříd nebo vlastností, budeme specifikovat
                  alternativní název některých vlastností. Zároveň
                  budeme chtít definovat v Caché vztah one-to-many mezi
                  třídami faktura a polozka.
package ucto; 
                  import com.intersys.pojo.annotations.*; 
                  
                  // vystavene faktury 
                  @CacheClass(name=”ucto.faktura”,
                  xmlSerializable=true) 
                  @Index(name=”cislofakturyIndex”, isUnique=true,
                  propertyNames={“cislofaktury”})
                  public class faktura { 
                  
@CacheProperty(name=”cislofaktury”)public String cislo_faktury;@CacheProperty(name=”datumvystaveni”)
                  public Date datum_vystaveni;
@Relationship(type=RelationshipType.ONE_TO_MANY,
                  inverseClass="ucto.polozka",
                  inverseProperty="faktura")
                  public ArrayList<polozka> polozky; // reference
                  na tridu ucto.polozka
public String
                  prijemce;
                  public Boolean vystavena;
@CacheProperty(name=”splatnokedni”)
                  public Date splatno_ke_dni;
                  public Boolean splaceno;
                  public Float castka;
                  }
Takto upravená definice třídy povede k vytvoření
                  následující třídy v Caché.
Class ucto.faktura Extends
                  (%Library.Persistent, %XML.Adaptor) [ SqlTableName =
                  faktura ]
                  {
                  
Property castka
                  As %Library.Float(JAVATYPE = "java.lang.Float");
                  Property cislofaktury As %Library.String(JAVATYPE =
                  "java.lang.String", MAXLEN = 4096) [ ClientName =
                  cislo_faktury ];
                  Property datumvystaveni As %Library.Date(JAVATYPE =
                  "java.util.Date") [ ClientName = datum_vystaveni
                  ];
                  Relationship polozky As ucto.polozka(JAVATYPE =
                  "java.util.ArrayList") [ Cardinality = many, Inverse
                  = faktura ];
                  Property prijemce As %Library.String(JAVATYPE =
                  "java.lang.String", MAXLEN = 4096);
                  Property splacena As %Library.Boolean(JAVATYPE =
                  "java.lang.Boolean");
                  Property splatnokedni As %Library.Date(JAVATYPE =
                  "java.util.Date") [ ClientName = splatno_ke_dni ];
                  Property vystavena As %Library.Boolean(JAVATYPE =
                  "java.lang.Boolean");
                  Index cislofakturyIndex On cislofaktury [ Unique
                  ];
                  XData JavaBlock
                  {
<JavaBlock>
                    <Package implementation="ucto.cache"
                    pojo="ucto"></Package>
                    <UseSameNames>false</UseSameNames>
                    <Name implementation="faktura"
                    pojo="faktura"></Name>
                    <ResolveNameCollisions>false</ResolveNameCollisions>
                    <EagerFetchRequired>true</EagerFetchRequired>
                    </JavaBlock>
                  }
                
}
O tom, jak třídu v Caché pomocí průvodce vytvoříme,
                  si povíme příště.
