JasperReports

import java.io.*;
 import java.util.HashMap;
 import java.util.Map;
 import net.sf.jasperreports.engine.*;
 import net.sf.jasperreports.view.*;
 import net.sf.jasperreports.engine.JasperCompileManager;

 /**
  * @author Elinton Dozol Machado
  * @version 1.0
  */

 public class Relatorio{

     private String arquivoXML = "Relatorio.xml";
     private String arquivoXML_OLD = "";
     private String parametros[] ;
     private String conteudo[] ;
     private static JasperReport jrImpressao;

     /**Construtor Padrão. */
     public Relatorio() {}

     /**Construtor
     *
     * @param arquivoXML caminho do arquivo XML.
     */
     public Relatorio(String arquivoXML){
    	 this.arquivoXML = arquivoXML;
     }
     /**Construtor que recebe o caminho do XML seus parametros e os valores que os preencherão
     *
     * @param arquivoXML caminho do arquivo XML.
     * @param listaParametros lista de parametros do XML
     * @param listaValores lista com os valores que preencherão os parametros
     */
     public Relatorio(String arquivoXML, String listaParametros[], String listaValores[]){
    	 this.arquivoXML = arquivoXML;
    	 parametros = listaParametros;
    	 conteudo = listaValores;
         try{
    		 gerarConteudo();
        }catch(Exception exe){
             System.out.println("Erro: "+ exe.getMessage());
        }

     }
     public void mostraRelatorio() throws IOException {
         try {
             JasperViewer.viewReport(gerarConteudo(),false);
         }catch(JRException jrex) {
             throw new IOException(jrex.getMessage());
         }
     }
     private JasperReport getJasperReportImpressao() throws JRException, IOException {
         try{
	    	 if((jrImpressao == null)||(!(arquivoXML_OLD.equalsIgnoreCase(arquivoXML)))) {
	             jrImpressao = JasperCompileManager.compileReport(new BufferedInputStream(getClass().
	             getResourceAsStream(arquivoXML))); // Localizacao do arquivo XML exibido acima.
	                 arquivoXML_OLD = arquivoXML;
	         }
         }catch(JRException jrex){
        	 System.out.println("Erro causa:"+jrex.getMessage()+jrex.getMessage());
        	 throw new JRException(jrex.getCause());
         }catch(Exception jrex){
        	 System.out.println("Erro de IO"+jrex.getCause()+jrex.getMessage());
         }
         return jrImpressao;
     }
     private JasperPrint gerarConteudo() throws JRException, IOException {
         int intQuantidade = parametros.length;
    	 Map parameters = new HashMap(intQuantidade);
         for (int i = 0; i < intQuantidade; i++ )
        	 parameters.put(parametros[i], conteudo[i]);
         return JasperFillManager.fillReport(this.getJasperReportImpressao(),
             parameters, new JREmptyDataSource());
     }

     private String lerHTML(OutputStream osHTML, File fileHTML,
             String fileName) throws IOException, JRException {
         fileHTML = new File(fileName);
         JasperExportManager.exportReportToHtmlFile(this.gerarConteudo(),
             fileName);
         BufferedReader rd = new BufferedReader(
             new InputStreamReader(new FileInputStream(fileHTML)));
         String s;
         StringBuffer sbHTML = new StringBuffer();
         while((s = rd.readLine()) != null) {
             sbHTML.append(s + "  ");
         }
         rd.close();
         return sbHTML.toString();
     }


     private void fecharStreams(OutputStream osHTML, File fileHTML,
             String fileName) throws IOException {
         if(osHTML != null) {
             osHTML.flush();
             osHTML.close();
         }
         if((fileHTML != null) && fileHTML.exists()) {
             fileHTML.delete();
         }
         fileHTML = new File(fileName + "_files");
         if((fileHTML != null) && fileHTML.exists() && fileHTML.isDirectory()) {
             fileHTML.delete();
         }
     }

     /**Determina os parametros do Relatório. Método sem Efeito
      *
      * @param strParametros parametros do Relatório.
      */
     public void setParametros(String[] strParametros) {
         this.parametros = strParametros;
     }

     /**Determina o conteudo das páginas do Relatório.
      *
      * @param strConteudo Cabeçalho das páginas do Relatório.
      */
     public void setConteudo(String[] strConteudo) {
         this.conteudo = strConteudo;
     }
     /**Gera um relatorio para a Impressão
      *
      * @param verDialogoDeImpressao Se quer ver o diálogo de impressão.
      * @exception IOException SE ocorrer algum problema de I/O, ou na geração
      * de conteúdo ou quando enviar o relatório a impressora.
      */
     public void gerarImpressao(boolean verDialogoDeImpressao) throws IOException {
         try {
        //	 JasperViewer.viewReport(gerarConteudo(),false);
        	 JasperPrintManager.printReport(this.gerarConteudo(),
             verDialogoDeImpressao);

         } catch(JRException jrex) {
             throw new IOException(jrex.getMessage());
         }
     }

     /**Gera versao HTML do Relatório.
      *
      * @return String com o conteudo HTML do Relatório.
      */
     public String gerarHTML() {
         String strHTML = null;
         OutputStream osHTML = null;
         File fileHTML = null;
         String fileName = System.currentTimeMillis() + ".html";
         try {
             strHTML = this.lerHTML(osHTML, fileHTML, fileName);
         } catch(IOException ioex) {
             throw new RuntimeException(ioex);
         } catch(JRException jrex) {
             throw new RuntimeException(jrex);
         } finally {
             try {
                 this.fecharStreams(osHTML, fileHTML, fileName);
             } catch(IOException ioex) {
                 throw new RuntimeException(ioex);
             }
         }
         return strHTML;
     }

     /**
      *
      * @return Stream com o versao PDF do Relatório.
      * @throws IOException Se ocorrer um problema de I/O ou na criacao do
      * Conteudo.
      */
     public OutputStream gerarStreamPDF() throws IOException {
         byte[] bytePDF = this.gerarPDF();
         OutputStream osPDF = new
             BufferedOutputStream(new ByteArrayOutputStream(bytePDF.length));
         osPDF.write(bytePDF);
         osPDF.flush();
         return osPDF;
     }

     /**
      *
      * @return Vetor de bytes com a versao PDF do Relatório.
      * @throws IOException Se ocorrer um problema de I/O.
      */
     public byte[] gerarPDF() throws IOException {
         byte[] bytePDF = null;
         try {
             bytePDF = JasperExportManager.exportReportToPdf(this.gerarConteudo());
         } catch(JRException jrex) {
             throw new IOException(jrex.getMessage());
         }
         return bytePDF;
     }


 }