JasperReports 4.0.1: Criando gráficos no iReport com JDBC datasource - Gráfico tipo: pizza

Depois de criarmos gráficos do tipo em barras, agora vamos criar gráficos do tipo pizza, para esta postagem eu vou usar JDBC datasouce, por ser mais prático, isso só para mostrar mesmo como criar gráficos usando o iReport.

Obs: qualquer semelhança inicialmente com a postagem sobre gráficos em barras é mera coincidência... brincadeira, é puro CTRL C + CTRL V hahaha

Banco de dados

Tendo as seguintes tabelas no banco de dados:

Se eu executar a seguinte query no banco:

select cliente.nome, sum(pedido.valor) as total from cliente, pedido 
where pedido.cliente_codigo = cliente.codigo 
group by cliente.nome 
order by total desc;

Levando em consideração os dados do meu banco, eu tenho o seguinte resultado:

Agora eu quero representar esses valores graficamente, para isso no iReport...

No iReport...

A partir daqui já estou considerando que já tenha um novo relatório criado, caso queira mais detalhes de como proceder com o JDBC datasource, veja o link lá do início.

Em Report query vou usar a mesma query acima, assim:

Depois de dar um OK, confirmo no Report Inspector se os fields foram criados:

Criando o gráfico...

Na paleta de elementos, procure por Chart:

Clique no elemento e arraste-o para a band summary, ao fazer isso, aparecerá a janela para selecionar o tipo de gráfico, neste exemplo vou usar o Pie 3D:

Na próxima janela clique em Finalizar (e não em próximo como parece selecionado na imagem):

O resultado será este:

Veja que neste exemplo eu tenho apenas as bands Tittle e Summary, quanto as outras eu removi.

Agora vamos configurar nosso gráfico, para isso clique com o botão direito no gráfico, e vá na opção Chart Data:

Na aba Details configure os campos de acordo com a imagem acima: e de acordo com os nomes dos seus fields, informe o nome do cliente para Key e o valor total do pedido para Value e Label. Feito basta dar um Close na janela, e pronto...

Basta clicar em Preview na janela do iReport, que já poderemos ver o resultado:

Bem simples!

JasperReports 4.0.1: Criando gráficos no iReport com JDBC datasource - Gráfico tipo: barras

Na postagem de hoje vamos gerar gráficos com JasperReports, para esta postagem eu vou usar JDBC datasouce, por ser mais prático, isso só para mostrar mesmo como criar gráficos usando o iReport.

Banco de dados

Tendo as seguintes tabelas no banco de dados:

Se eu executar a seguinte query no banco:

select cliente.nome, sum(pedido.valor) as total from cliente, pedido 
where pedido.cliente_codigo = cliente.codigo 
group by cliente.nome 
order by total desc;

Levando em consideração os dados do meu banco, eu tenho o seguinte resultado:

Agora eu quero representar esses valores graficamente, para isso no iReport...

No iReport...

A partir daqui já estou considerando que já tenha um novo relatório criado, caso queira mais detalhes de como proceder com o JDBC datasource, veja o link lá do início.

Em Report query vou usar a mesma query acima, assim:

Depois de dar um OK, confirmo no Report Inspector se os fields foram criados:

Criando o gráfico...

Na paleta de elementos, procure por Chart:

Clique no elemento e arraste-o para a band summary, ao fazer isso, aparecerá a janela para selecionar o tipo de gráfico, neste exemplo vou usar o Bar 3D:

Na próxima janela clique em Finalizar (e não em próximo como parece selecionado na imagem):

O resultado será este:

Veja que neste exemplo eu tenho apenas as bands Tittle e Summary, quanto as outras eu removi.

Agora vamos configurar nosso gráfico, para isso clique com o botão direito no gráfico, e vá na opção Chart Data:

Na aba Details clique no botão Add:

De acordo com os nomes dos seus fields, informe o nome do cliente para Series e Category e o valor total do pedido para Value. Feito isso dê OK na janela principal e um Close na janela abaixo, e pronto...

Basta clicar em Preview na janela do iReport, que já poderemos ver o resultado:

Bem simples!

JasperReports 4.0.1: JDBC datasource - abrir relatório em projeto desktop

Depois de vermos como chamar um relatório feito no JasperReports utilizando JDBC datasource em um projeto Web, nessa postagem vamos usar o mesmo relatório mas em um projeto Java Desktop!

Reveja algumas postagens:

JasperReports 4.0.1: Utilizando JDBC datasource

JasperReports 4.0.1: JDBC datasource - abrir relatório em projeto web

Começando...

Para começar, no NetBeans crie um novo Aplicativo Java com o nome de RelatorioJDBC. A estrutura final será esta aqui:

Feito isso, vamos começar a estruturar nosso projeto para usarmos .jasper (criado na postagem do link). Como estamos usando JDBC, precisamos ter uma conexão com o banco de dados, então em pacotes de código-fonte já existirá um pacote com o nome de relatoriojdbc, dentro dele crie um novo pacote com o nome de dao, dentro desse pacote crie a classe Java com o nome de Conexao (já foi utilizada em outras postagem que não utilizava JPA), segue o código-fonte:

public class Conexao {
    private String driver = "com.mysql.jdbc.Driver";
    private String URL = "jdbc:mysql://localhost/5tads";
    private String USER = "root";
    private String SENHA = "admin";
    private Connection conn;

    public Conexao() {
        try {
            Class.forName(driver);
            conn = (Connection) DriverManager.getConnection(URL, USER, SENHA);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public Connection getConn() {
        return conn;
    }

    public void fecharConexao() {
        try {
            conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

Obs: só lembrando que na URL, o 5tads corresponde à minha database.

Como nosso foco não é a conexão com o banco de dados, vamos prosseguir... agora no mesmo pacote relatoriojdbc.dao, vamos criar mais uma classe Java com o nome de ClienteDAO:

public class ClienteDAO {

    private Conexao conexao;
    private Statement stmt;

    public ClienteDAO() {
        conexao = new Conexao();
        try {
            stmt = (Statement) conexao.getConn().createStatement();
        } catch (SQLException ex) {
            ex.printStackTrace();
        }
    }

    public ResultSet clientesResultSet() {
        ResultSet rs = null;
        try {
            rs = stmt.executeQuery("SELECT * FROM cliente ORDER BY nome");
        } catch (Exception e) {
            e.printStackTrace();
        } 

        return rs;
    }
}

Veja que o nosso método clientesResultSet, retorna um ResultSet mesmo e não uma lista de clientes, ao usarmos a metodologia de JDBC datasource, é isto que precisamos passar para o .jasper, e não uma lista como na JavaBean datasource.

Agora precisamos de um lugar para guardar nosso .jasper, para isso crie a seguinte estrutura de pacotes:

relatoriojdbc.controle.relatorios, e dentro dele, coloque o arquivo .jasper (no meu caso relatorioJDBC .jasper):

Agora precisamos colocar as bibliotecas no projeto, caso não tenha baixado as bibliotecas do JasperReports, baixe por aqui.

De todas as bibliotecas disponibilizadas no link, para este tipo de relatório iremos usar apenas algumas delas, acabei filtrando e chegando as que realmente precisavam, então adicione ao projeto as seguintes bibliotecas:

* quanto a biblioteca do MySQL é do próprio NetBeans (mas pode ser encontrada facilmente no Google).

Agora que já temos nosso dao pronto, e como já criamos um pacote relatoriojdbc.controle.relatorios, já temos um pacote controle, e então dentro dele teremos uma classe Java com o nome de ClienteControle:

public class ClienteControle {

    private ClienteDAO dao;

    public void gerarRelatorio() {
        String arquivo = "src/relatoriojdbc/controle/relatorios/relatorioJDBC.jasper";

        dao = new ClienteDAO();
        JRDataSource jrds = new JRResultSetDataSource(dao.clientesResultSet());
        gerarRelatorioDesktop(jrds, null, arquivo);
    }

    private void gerarRelatorioDesktop(JRDataSource jrds, Map<Object, Object> parametros, String arquivo) {
        try {
            JasperPrint print = JasperFillManager.fillReport(arquivo, parametros, jrds);
            JasperViewer.viewReport(print, false);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Vamos ver o que esses métodos fazem: 

public void gerarRelatorio()

Inicialmente este método será chamado pela nossa classe Main (que foi criada por padrão no projeto), nesse método nós precisamos pegar o caminho exato do nosso arquivo .jasper, que lá no começo da postagem colocamos dentro do pacote relatoriojdbc.controle.relatorios para isso precisamos indicar o caminho corretamente.

Quanto ao jrRS: por termos utilizado JDBC datasource para gerar nosso .jasper, nos precisamos passar para nosso relatório um JRDataSource, que é formado por um Result Set  que é retornado pelo nosso método lá do ClienteDAO.

Ao chamar o gerarRelatorioDesktop, estamos passando um parâmetro null, esse corresponderia a uma Map, que serviria para passarmos parâmetros(que vai ficar pra outra postagem) para o nosso relatório...

Agora vamos ver o que acontece no:

gerarRelatorioDesktop(JRDataSource jrRS, Map<Object, Object> parametros, String arquivo)

Dentro de um try-catch(para capturar possíveis exceções) nós temos o método principal que é o responsável por gerar o que vai ser o nosso relatório, que é essa linha aqui:

JasperFillManager.fillReport... 

esse método não cria um arquivo .pdf fisicamente no computador, apenas gera ele como se fosse um arquivo temporário, e quem decide se quer salvar o relatório ou não é o usuário, depois disso, chamamos o JasperViewer que é o que eu chamo de "visualizador de relatórios" do próprio JasperReports (ao final eu mostro visualmente este visualizador)...

Depois de vermos a principal classe do projeto, vamos ver a classe Main.java (dentro do pacote relatoriojdbc) que vai ser a responsável por mostrar uma telinha em Swing que tem um jButton, e que quando clicar nele ele vai chamar nosso método gerarRelatorio() da nossa classe ClienteControle, veja o código da classe Main abaixo:

public class Main {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        JFrame frame = new JFrame("Meu relatorio!");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        JButton botao = new JButton("Chamar meu relatório!");
        botao.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent ae) {
                ClienteControle controle = new ClienteControle();
                controle.gerarRelatorio();
            }
        });

        frame.getContentPane().add(botao);
        frame.pack();
        frame.setVisible(true);

    }
}

Ao executar o projeto (F6) temos a seguinte tela (é bem essa grande tela aí abaixo):

Ao clicar no botão "Chamar meu relatório!", ele irá fazer o que o próprio nome dele já diz: Chamar o nosso relatório =) ... assim, aparece a seguinte tela do JasperViewer:

Por aqui finalizamos a visualização de relatórios feito no JasperReports utilizando JDBC datasource. =)