// création de la fabrique
TransformerFactory fabrique = TransformerFactory.newInstance();

// récupération du transformeur
Transformer transformer = fabrique.newTransformer();

/**
* pour définir une feuille de style, vous pouvez utiliser une Source comme paramètre
* File stylesheet = new File("stylesheet.xsl");
* StreamSource stylesource = new StreamSource(stylesheet);
* Transformer transformer = fabrique.newTransformer(stylesource); 
*/

// configuration du transformeur
transformer.setOutputProperty(OutputKeys.INDENT, "yes");
transformer.setOutputProperty(OutputKeys.ENCODING, "ISO-8859-1");

// création de la fabrique
TransformerFactory fabrique = TransformerFactory.newInstance();

// récupération de Templates
Templates template = fabrique.newTemplates();

/**
* pour définir une feuille de style, vous pouvez utiliser une Source comme paramètre
* File stylesheet = new File("stylesheet.xsl");
* StreamSource stylesource = new StreamSource(stylesheet);
* Templates template = fabrique.newTemplates(stylesource); 
*/

// configuration du transformeur
Transformer transformer = template.getTransformer();
transformer.setOutputProperty(OutputKeys.INDENT, "yes");
transformer.setOutputProperty(OutputKeys.ENCODING, "ISO-8859-1");

import javax.xml.transform.*; 
public class EcouteurDErreurs implements ErrorListener{
    public void warning(TransformerException exception)
             throws TransformerException{
       printException(exception);      
    }
    public void error(TransformerException exception)
           throws TransformerException{
       printException(exception);    
    }
    public void fatalError(TransformerException exception)
                throws TransformerException{
       printException(exception);
       throw exception;
    }
    private void printException(TransformerException exception){
    String message = exception.getMessageAndLocation() ;
    System.out.println(message);
    }
}

Transformer transformeur = ...; 
transformeur.setErrorListener(new EcouteurDErreurs());

public static void transformerXml(Document document, String fichier) {
   try {
      // Création de la source DOM
      Source source = new DOMSource(document);

      // Création du fichier de sortie
      File file = new File(fichier);
      Result resultat = new StreamResult(fichier);

      // Configuration du transformer
      TransformerFactory fabrique = TransformerFactory.newInstance();
      Transformer transformer = fabrique.newTransformer();
      transformer.setOutputProperty(OutputKeys.INDENT, "yes");
      transformer.setOutputProperty(OutputKeys.ENCODING, "ISO-8859-1");

      // Transformation
      transformer.transform(source, resultat);
   }catch(Exception e){
      e.printStackTrace();
   }
}

Personne
/**
  * Voir zip
  */

AnnuaireSource
public class AnnuaireSource extends InputSource{
   private List<Personne> personnes;
   public AnnuaireSource(List<Personne> personnes){
      super();
      this.personnes = personnes;
   }
   public List<Personne> getPersonnes(){
      return personnes;
   }
   // En fait, contrairement à cet exemple de nombreuses méthodes d'InputSource travaillent avec des streams.
   // Cela peut vous simplifier le travail sur des fichiers XML existants.
}

AnnuaireReader
public class AnnuaireReader implements XMLReader{
   private ContentHandler handler;
   private AttributesImpl atts = new AttributesImpl();
   //méthode qui vont être utilisées par le transformer
   public ContentHandler getContentHandler(){
      return handler;
   }
   public void setContentHandler(ContentHandler handler){
      this.handler = handler;
   }
   // parsing d'une liste de personnes
   public void parse(InputSource input) throws IOException,SAXException{
      if(!(input instanceof AnnuaireSource)){
         String m = "Le seul argument possible pour parse est une AnnuaireSource";
         throw new SAXException(m);
      }
      if(handler == null){
         throw new SAXException("Pas de ContentHandler");
      }
      AnnuaireSource source = (AnnuaireSource)input;
      List<Personne> personnes = source.getPersonnes();

      handler.startDocument(); 
      handler.startElement("", "annuaire", "annuaire", atts);
      for(Personne p : personnes){
         atts.addAttribute("","id","id","",String.valueOf(p.getId()));
         handler.startElement("", "personne", "personne", atts);
         atts.clear();

         handler.startElement("", "nom", "nom", atts);
         char[] nom = p.getNom().toCharArray();
         handler.characters(nom,0,nom.length);
         handler.endElement("", "nom", "nom");

         handler.startElement("", "prenom", "prenom", atts);
         char[] prenom = p.getPrenom().toCharArray();
         handler.characters(prenom,0,prenom.length);
         handler.endElement("", "prenom", "prenom");

         handler.startElement("", "adresse", "adresse", atts);
         char[] adresse = p.getAdresse().toCharArray() ;
         handler.characters(adresse,0,adresse.length);
         handler.endElement("", "adresse", "adresse");

         handler.endElement("", "personne", "personne");
      }
      handler.endElement("", "annuaire", "annuaire");
      handler.endDocument();
   }
   public void parse(String systemId) throws IOException,SAXException{
      String m = "Le seul argument possible pour parse est une AnnuaireSource";
      throw new SAXException(m);
   }
   // autres méthodes à implémenter
}

// Création de l'annuaire
List<Personne> annuaire = new ArrayList<Personne>();
// ...
//remplissage de l'annuaire

// Création de la source DOM
XMLReader annuaireReader = new AnnuaireReader();
InputSource annuaireSource = new AnnuaireSource(annuaire); 
Source source = new SAXSource(annuaireReader, annuaireSource);

// Création du fichier de sortie
File file = new File("CreationSAX.xml");
Result resultat = new StreamResult(file);

// Configuration du transformer
TransformerFactory fabrique = TransformerFactory.newInstance();
Transformer transformer = fabrique.newTransformer();
transformer.setOutputProperty(OutputKeys.INDENT, "yes");
transformer.setOutputProperty(OutputKeys.ENCODING, "ISO-8859-1");

// Transformation
transformer.transform(source, resultat);

public static void creerHTML(String xml, String xsl, String html) throws Exception{
// Création de la source DOM
DocumentBuilderFactory fabriqueD = DocumentBuilderFactory.newInstance();
DocumentBuilder constructeur = fabriqueD.newDocumentBuilder();
File fileXml = new File(xml);
Document document = constructeur.parse(fileXml);
    Source source = new DOMSource(document);

    // Création du fichier de sortie
    File fileHtml = new File(html);
    Result resultat = new StreamResult(fileHtml);

    // Configuration du transformer
    TransformerFactory fabriqueT = TransformerFactory.newInstance();
    StreamSource stylesource = new StreamSource(xsl);
    Transformer transformer = fabriqueT.newTransformer(stylesource);
    transformer.setOutputProperty(OutputKeys.METHOD, "html");
    
    // Transformation
    transformer.transform(source, resultat);
}

public static void creerPDF(String xml, String xsl, String pdf) throws Exception{
   // création du résultat (pdf)
   Driver driver = new Driver();
   driver.setRenderer(Driver.RENDER_PDF);
   driver.setOutputStream(new java.io.FileOutputStream(pdf));
   Result resultat = new SAXResult(driver.getContentHandler());

   // récupération de la source xml
   Source source = new StreamSource(xml);

   // création du transformer en fonction du xsl
   Source style = new StreamSource(xsl);
   TransformerFactory transformerFactory = TransformerFactory.newInstance();
   Transformer transformer = transformerFactory.newTransformer(style);

   // transformation
   transformer.transform(source, resultat);
}

Source image = J2EE 1.4 Tutorial

public static void transformer(File xml,
            File xsl1, 
            File xsl2,
            File html) throws Exception{
   // Création du reader initial
   SAXParserFactory spf = SAXParserFactory.newInstance();
   spf.setNamespaceAware(true);
   XMLReader reader = spf.newSAXParser().getXMLReader();

   // Création des filtres à appliquer au reader
   SAXTransformerFactory stf = (SAXTransformerFactory)TransformerFactory.newInstance();
   XMLFilter filtre1 = stf.newXMLFilter(new StreamSource(xsl1));
   XMLFilter filtre2 = stf.newXMLFilter(new StreamSource(xsl2));

   // On "lie" le reader aux filtres
   filtre1.setParent(reader);
   filtre2.setParent(filtre1);

   // Création de la source : c'est le dernier filtre de la chaîne
   // C'est lui qui indiquera au transformer quelles transformations à faire "avant"
   // Le résultat est le fichier HTML
   SAXSource source = new SAXSource(filtre2, new InputSource(new FileInputStream(xml)));
   StreamResult resultat = new StreamResult(new FileOutputStream(html));

   //Transformation en chaîne
   Transformer transformer = stf.newTransformer();
   transformer.transform(source, resultat);
}