Jasper Report + Tapestry

               <dependency>
                        <groupId>net.sf.jasperreports</groupId>
                        <artifactId>jasperreports</artifactId>
                        <version>5.0.0</version>
                </dependency>

@Getter
@Setter
@EqualsAndHashCode(of = {"id"})
public final class File {

        private long id;

        private String title;

        private String name;

        private String type;

        private long size;

        private byte[] content;

        private String extension;

       //Getters y setters si no usan lombok

        /**
         * NO CAMBIAR esta parte pues es utilizada en la clase de creacion de StreamResponse (StreamResponseFactory.java)
         */
        @Override
        public String toString() {
                StringBuilder builder = new StringBuilder();
                builder.append("inline;filename=");
                builder.append(name);
                builder.append(".");
                builder.append(extension);
                return builder.toString();
        }
}

/**
  *Clase para la generacion del reporte.
  */
public class JasperReportGenerator {

    private static final Logger LOG = LoggerFactory.getLogger(JasperReportGenerator.class);
   
   /**
    * name: Nombre del reporte
    * asset: Enum que contiene la URL de la plantilla del reporte ya compilado
    * type: Enum que contiene el tipo de impresora de jasper, asi como el tipo de archivo y extencion del archivo
    * beanCollection: Es la colleccion de objetos que se desplegaran en el reporte y puede ser cualquier POJO, las propiedades del POJO tendran que estar como fields en el reporte de jasper, jasper se encargara de la obtencion de los valores de cada objeto.
    */
    public File generate(
            String name,
            JasperAssets asset,
            JasperReportType type,
            Collection<?> beanCollection) {

        // baos se encarga de almacenar el reporte ya impreso en un arreglo de bytes
        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        JasperReport report = null;
        JasperPrint jasperPrint = null;

        try {
            report = (JasperReport) JRLoader
                    .loadObject(new URL(asset.getURL()));
           
            jasperPrint = JasperFillManager.fillReport(
                    report,
                    null,
                    new JRBeanCollectionDataSource(beanCollection));
           
            JRExporter exporter = type.getExporter();

            exporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
            exporter.setParameter(JRExporterParameter.OUTPUT_STREAM, baos);
            exporter.exportReport();

        } catch (MalformedURLException e) {
            LOG.error("------ [ Error de malformacion ] ------", e);
            LOG.error("------ [ {} ] ------", e.getMessage());
        } catch (JRException e) {
            LOG.error("------ [ Error de JasperReport ] ------", e);
            LOG.error("------ [ {} ] ------", e.getMessage());
        }
       
        //Retornamos un File pues es nuestro wrapper de archivos
        return buildFile(name, baos, type);
    }
   
    private File buildFile(
            String name,
            ByteArrayOutputStream baos,
            JasperReportType type) {
       
        File file = new File();
        file.setContent(baos.toByteArray());
        file.setExtension(type.getExtension());
        file.setName(name);
        file.setSize(baos.size());
        file.setTitle(name);
        file.setType(type.getType());
       
        return file;
    }
}

/**
  * Genera StreamResponse de tapestry. Se puede utilizar para abrir una nueva pagina o descarga con liga en la misma pagina.
  * Se utiliza para la obtencion de Reportes en Jasper u obtencion de archivos almacenados en DB.
  */
public final class StreamResponseFactory {

    /**
     * Se le pasa un File que contiene la informacion del archivo para generar un streamResponse
     */
    public StreamResponse getResponse(final File file) {
       
        return new StreamResponse() {

            @Override
            public void prepareResponse(Response response) {
                response.setHeader("Content-Disposition", file.toString());
            }

            @Override
            public InputStream getStream() throws IOException {
                return new ByteArrayInputStream(file.getContent());
            }

            @Override
            public String getContentType() {
                return file.getType();
            }
        };
       
    }

}

public enum JasperReportType {
   
    PDF(new JRPdfExporter(), "pdf", "application/pdf"),
    XLS(new JRXlsExporter(), "xls", "application/vnd.ms-excel");
   
    private JRExporter exporter;
   
    private String extension;
   
    private String type;

    /**
     * @param exporter
     * @param extension
     * @param type
     */
    private JasperReportType(
            JRExporter exporter,
            String extension,
            String type) {
        this.exporter = exporter;
        this.extension = extension;
        this.type = type;
    }

    /**
     * @return the exporter
     */
    public JRExporter getExporter() {
        return exporter;
    }

    /**
     * @return the extension
     */
    public String getExtension() {
        return extension;
    }

    /**
     * @return the type
     */
    public String getType() {
        return type;
    }

}

public enum JasperAssets {
   
    RECEIPT_TOOLS_STOCK("toolsStock.jasper"),
    TICKET_EXPORTER("ticketExporter.jasper");
    //TODOS los demas ...

    private final String name;
   
    private SimaAssets(String name) {
        this.name = name;
    }
   
    public String getURL() {
        return "http://host/" + name;
    }
   
}

    public StreamResponse toExcel(final List<Ticket> tickets){
               
                File file = jasperReportGenerator.generate(
                        "Concentrado",      //Nombre del reporte
                        JasperAssets.TICKET_EXPORTER,  //Que plantilla deseo
                        JasperReportType.XLS,      //Que tipo de plantilla es (EXCEL en este caso)
                        tickets);    // Y la informacion que llevara el reporte
               
                LOG.info("------ [ Saliendo: toExcel() ] ------");
               
                return streamResponseFactory.getResponse(file);  // Dado el File generado lo mando aun StreamResponse
        }

       /** LLamada desde un action link, los ticket ya han sido cargados en el onActivate de la pagina */
       StreamResponse onActionFromToExcel(){
                return ticketService.toExcel(tickets);
        }

public class DatosDeReporte {
  private String   name
  private String   age
  private String   description
  private Date   date

  //getters y setters...
}