Programação Comercial Sumário

Transcrição

1 Programação Comercial Para a fixação do conhecimento, uma sequência de práticas detalhas a seguir deve ser executada. Nesta sequência de práticas, uma pequena aplicação para o cadastro e manutenção de dados de clientes, fornecedores e pedidos será criada. Para a realização das práticas é necessário que o banco de dados MySQL esteja instalado e iniciado. As práticas serão realizadas no IDE Netbeans. Sumário Prática 1: Banco de Dados Modelo do banco de dados da aplicação Pedido Acessando o servidor MySQL através do Netbeans Criando o banco de dados e as tabelas Exercícios...5 Prática 2: Definindo os Value Objects para as tabelas Criando um novo projeto Criando enum TipoLogradouro e TipoUnidadeFederada Enum TipoLogradouro Enum TipoUnidadeFederada Exercícios O Value Object Cliente Exercícios...8 Prática 3: Acessando o banco de dados Classe utilitária para a conexão com o banco de dados Implementação da classe ConexaoBD Driver JDBC para a conexão com o banco de dados Teste de Unidade da classe ConexaoBD Utilizando um arquivo de configuração (propriedades) Exercícios Prática 4: Padrão de Projeto Data Access Object (DAO) Manipulando registros de clientes DAO para a tabela cliente Testando a tabela cliente Exercícios Manipulando registros de produtos DAO para a tabela produto Testando a tabela produto Exercícios Manipulando registros de pedidos DAO para a tabela pedido Testando a tabela pedido Exercícios Prática 5: Denvolvimento da interface gráfica da aplicação Tela principal da aplicação Menu principal da aplicação Aplicação Multi Document Interface (MDI) Exercícios Tela do cadastro de clientes Criação da janela filha de cadastro de clientes Criação do painel com guias (JTabbedPane) Design da aba Cadastro Design da aba Registros Exercícios Consulta de Pedidos por Cliente Criando a tela de consulta Exercícios Prática 6: Cadastro de Pedidos Classe utilitária para a formatação de dados Implementação da classe utilitária

2 6.1.2 Exercício Ajustes nos value objects Alterando as JavaBeans Exercício Formulário de cadastro de pedidos O formulário de entrada de dados

3 Prática 1: Banco de Dados Nesta prática, criaremos o banco de dados e também a estrutura de tabelas para trabalharmos em nosso projeto. 1.1 Modelo do banco de dados da aplicação Pedido Na Figura 1, ilustrada abaixo, está representado o diagrama do modelo de dados que iremos utilizar em nosso projeto. Figura 1: Modelo de dados da aplicação 1.2 Acessando o servidor MySQL através do Netbeans 1. Com o Netbeans aberto, acione o comando de menu Janela > Serviços (Ctrl + 5); 2. Clique no item Banco de Dados, com o botão direito do mouse, acionando o comando Nova Conexão...; 3. Selecione o Driver MySQL (Connector/J driver) e clique no botão Próximo; 4. Limpe o conteúdo do campo Banco de dados (caso tenha definido uma senha, esta deve ser informada) e clique em Testar Conexão; 5. Clique no botão Próximo; 6. Clique no botão Próximo novamente; 7. Altere o nome da conexão para MySQL e clique no botão Finalizar para fechar a janela; 8. Clique com o botão direito do mousesobre a nova conexão que acabamos de criar (MySQL) e acione o comando Conectar; 9. Na janela de diálogo que solicita o usuário e a senha, deixe os valores em branco (a não ser que você tenha definido uma senha) e clique em OK; 10. Clique com o botão direito do mouse novamente sobre a conexão anterior (MySQL) e acione o comando Executar Comando..., onde será aberta uma nova janela para inserção de comandos SQL; 11. Execute o comando abaixo para listar os bancos de dados existentes e verificar que a conexão está funcionando adequadamente: show databases 1.3 Criando o banco de dados e as tabelas 1. Crie o banco de dados, executando o comando SQL abaixo: create database pedido 2. Note que a lista de banco de dados foi automaticamente atualizada, contendo também o banco de dados recém-criado; 3. Selecione o banco de dados pedido, utilizando o comando SQL abaixo (se não fizer isso, as instruções SQL 3

4 para a criação de tabelas necessitarão do nome completo de cada uma das tabelas criadas e suas referências): use pedido 4. Agora, precisamos criar as tabelas e, para isso, devemos executar as instruções SQL abaixo (digite os comandos em vezde apenas copiar e colar): CREATE TABLE `cliente` ( `clicod` int(11) NOT NULL AUTO_INCREMENT, `clinome` varchar(100) NOT NULL, `clicpf` varchar(14) NOT NULL, `clitelefone` varchar(20) NOT NULL, `cli ` varchar(100) NOT NULL, `cliendcep` varchar(10) NOT NULL, `cliendtiplogradouro` int(2) NOT NULL, `cliendlogradouro` varchar(40) NOT NULL, `cliendnumero` varchar(10) NOT NULL, `cliendcomplemento` varchar(40) NOT NULL, `cliendbairro` varchar(40) NOT NULL, `cliendmunicipio` varchar(40) NOT NULL, `clienduf` char(2) NOT NULL, PRIMARY KEY (`clicod`) ) ENGINE=InnoDB DEFAULT CHARSET=latin1; CREATE TABLE `fornecedor` ( `forcod` int(11) NOT NULL AUTO_INCREMENT, `fornome` varchar(100) NOT NULL, `forcnpj` varchar(18) NOT NULL, `fortelefone` varchar(20) NOT NULL, `forfax` varchar(20) NOT NULL, `for ` varchar(100) NOT NULL, `forwebsite` varchar(100) NOT NULL, PRIMARY KEY (`forcod`) ) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=latin1; CREATE TABLE `produto` ( `procod` int(11) NOT NULL AUTO_INCREMENT, `forcod` int(11) NOT NULL, `pronome` varchar(100) NOT NULL, `prodescricao` text NOT NULL, `prounimedida` int(2) NOT NULL, `provalunitario` decimal(20,2) NOT NULL, PRIMARY KEY (`procod`), KEY `forcod` (`forcod`), CONSTRAINT `fornecedor_produto_fk` FOREIGN KEY (`forcod`) REFERENCES `fornecedor` (`forcod`) ) ENGINE=InnoDB DEFAULT CHARSET=latin1; CREATE TABLE `pedido` ( `pedcod` int(11) NOT NULL AUTO_INCREMENT, `clicod` int(11) NOT NULL, `peddata` date NOT NULL, PRIMARY KEY (`pedcod`), KEY `clicod` (`clicod`), CONSTRAINT `cliente_pedido_fk` FOREIGN KEY (`clicod`) REFERENCES `cliente` (`clicod`) ) ENGINE=InnoDB DEFAULT CHARSET=latin1; CREATE TABLE `pedido_item` ( `pedcod` int(11) NOT NULL, `procod` int(11) NOT NULL, `pedproquantidade` decimal(15,3) NOT NULL, PRIMARY KEY (`pedcod`,`procod`), 4

5 KEY `procod` (`procod`), CONSTRAINT `pedido_item_fk` FOREIGN KEY (`pedcod`) REFERENCES `pedido` (`pedcod`), CONSTRAINT `produto_pedido_item_fk` FOREIGN KEY (`procod`) REFERENCES `produto` (`procod`) ) ENGINE=InnoDB DEFAULT CHARSET=latin1; 5. Veja que a lista de tabelas foi atualizada, com as cinco tabelas do modelo de dados (Figura 1); 6. A janela de execução de comandos SQL é uma importante janela que você pode utilizar para executar qualquer comando SQL para qualquer banco de dados para o qual tenha criado uma conexão; 7. Portanto, busque estudar mais sobre banco de dados, incluindo comandos SQL e sobre o banco de dados em que estiver trabalhando. 1.4 Exercícios 1. Crie o banco de dados pedido no MySQL. 2. Crie as tabelas desta prática no banco de dados MySQL. 3. Insira alguns registros em cada uma das tabelas, usando o assistente visual de consulta do Netbeans: cliente, fornecedor, produto, pedido, pedido_item. 4. Insira alguns registros nas tabelas do exercício acima usando comandos SQL. 5. Faça consultas ao banco dedados usando instruções SQL. 5

6 Prática 2: Definindo os Value Objects para as tabelas Nesta prática começaremos a implementar o sistema. Para tanto, será necessário criarmos algumas implementações de suporte para que possamos utilizar no na nossa aplicação. Para entendermos melhor como funciona a comunicação com o banco de dados, a implementação será manual, somente com as classes mais básicas, sem uso de frameworks e APIs, pois para utilizarmos seria necessário primeiro dominar o código mais básico antes de se pensar em ter produtividade com o uso deles, pois mesmo que os frameworks como JPA e CDI possam tornar o processo de desenvolvimento mais produtivo, caso ocorra algum problema, poderemos perder mais tempo do que se estivermos implementando sem eles. 2.1 Criando um novo projeto 1. No Netbeans, acione o comando de menu Janela > Projetos (Ctrl + 1); 2. Acione o comando Arquivo > Novo Projeto...; 3. Na janela Novo Projeto, selecione a categoria Java e o tipo de projeto Aplicação Java; 4. Clique no botão Próximo; 5. Informe sisped como o nome do projeto; 6. Informe um local para iniciar o projeto; 7. Marque a opção Usar Pasta Dedicada para Armazenar Bibliotecas; 8. Desmarque a opção Criar Classe Principal; 9. Clique no botão Finalizar. 2.2 Criando enum TipoLogradouro e TipoUnidadeFederada Observe que no modelo de dados (Figura 1) a tabela cliente possui o campo para tipo de logradouro definido como int(2), armazenando somente o código, e o campo para a unidade federada como char(2), armazenando somente a sigla. Esse tipo de implementação em banco de dados é comum, evitando que sejam criadas tabelas para listas que sejam alteradas com uma frequência muito baixa. Nesta situação, é necessário existir uma documentação que liste tanto os códigos como as descrições, para que não ocorram problemas de uso incorreto de código. Para facilitar a implementação deste cenário, o Java fornece um tipo especial denominado enum, em que podemos definir uma lista de constantes e, se necessário, incluir atributos e construtores para a definição mais detalhada da implementação Enum TipoLogradouro 1. Crie um pacote chamado br.edu.univag.sisped.tipo, para armazenarmos os tipos da nossa aplicação; 2. No pacote criado acima, crie um enum clicando com o botão direito do mouse sobre o pacote e acionando comando Novo > Outros; 3. Selecione a categoria Java, o tipo de arquivo Enum Java e clique no botão Próximo; 4. Informe o nome da classe TipoLogradouro e clique no botão Finalizar; 5. Inclua no início do enum TipoLogradouro as seguintes constantes: AVENIDA, RUA, OUTROS; 6. Note que não foi necessário definir a visibilidade e nem o tipo de cada literal; 7. Isso acontece porque as literais dentro de um enum Java já são public e final e possuem o mesmo tipo do enum onde se encontram; 8. Como os enum Java não geram um código interno próṕrio, é interessante criarmos atributos para que possamos armazenar os dados no formato que precisamos para a nossa aplicação; 9. Crie os atributos para o armazenamento do código e da descrição de cada tipo de logradouro: private final int codigo; private final String descricao; 9. O compilador irá reclamar que esses dois atributos não foram inicializados pelo construtor, portanto, crie um construtor usando as teclas de atalho <Ctrl> + <Espaço>, selecionando o construtor que recebe os parâmetros para popular os dois atributos: private TipoLogradouro(int codigo, String descricao) { this.codigo = codigo; this.descricao = descricao; 6

7 10. Agora, o compilador irá reclamar que os valores constantes do enum não podem ser aplicados aos contrutores disponíveis, então precisamos alterar esses valores, passando tanto o código como a descrição de cada constante que definimos antes: AVENIDA(1, "Avenida"), RUA(2, "Rua"), OUTROS(99, "Outros"); 11. Como os atributos precisam ser acessados pelas classes do projeto, crie os acessores (somente os getters) para os atributos codigo e descricao que possuem a visibilidade private, acionando o atalho de teclado <Alt> + <Insert>. 12. Para finalizar, crie um método de classe (static) para permitir que um tipo de logradouro seja recuperado através de seu código: public static TipoLogradouro get(int codigo) { TipoLogradouro resposta = null; for (TipoLogradouro t : values()) { if (t.getcodigo() == codigo) { resposta = t; return resposta; Enum TipoUnidadeFederada Em muitas situações as Unidades Federadas são implementadas no código-fonte em vez de se criarem tabelas no banco de dados para o armazenamento delas. Isto ocorre porque as unidades federadas não são criadas ou alteradas com frequência. E, quando são criadas novas Unidades Federadas ou algum nome é alterado, é necessário aguardar um prazo para que a lei possa entrar em vigor, dando tempo suficiente para alterar as definições dos códigos-fonte existentes nas aplicações implementadas. Sendo assim, iremos implementar as Unidades Federadas também no código-fonte: 1. Crie um novo enum Java chamado TipoUnidadeFederada no pacote br.edu.univag.sisped.tipo; 2. Inclua as siglas e nomes de alguns estados brasileiros: AC("AC", "Acre"), AM("AM", "Amazonas"), MT("MT", "Mato Grosso"), RJ("RJ", "Rio de Janeiro"), SP("SP", "São Paulo"); 3. Crie os atributos para o armazenamento das siglas e nomes dos estados brasileiros; private final String sigla; private final String nome; 4. Crie um construtor parametrizado para inicializar as siglas e nomes de cada valor do enum: private TipoUnidadeFederada(String sigla, String nome) { this.sigla = sigla; this.nome = nome; 5. Crie os métodos acessores para que os valores dos atributos possam ser utilizados por outras classes: public String getsigla() { return sigla; public String getnome() { return nome; 6. Note que desta vez usamos um atributo do tipo String para a identificação (sigla) em vez do tipo int; 7. Finalmente, crie um método estático para obter uma unidade federada através de sua sigla: public static TipoUnidadeFederada get(string sigla) { TipoUnidadeFederada resposta = null; for (TipoUnidadeFederada t : values()) { 7

8 if (t.getsigla().equals(sigla)) { resposta = t; return resposta; Exercícios 1. Pesquise e responda: por que os construtores dos enum Java possuem a visibilidade private? 2. Pesquise sobre os métodos equals e hashcode, implementados na classe Object e que devem ser sobrescritos em certas subclasses para atender à certas necessidades. Quando eles são necessários? 3. Complete a lista de tipos de logradouro, incluindo os tipos que faltam (se alterar o código, deverá ajustar o valor do campo associado para manter a integridade dos dados): aeroporto, alameda, área, campo, chácara, colônia, condomínio, conjunto, distrito, esplanada, estação, estrada, favela, fazenda, feira, jardim, ladeira, lago, lagoa, largo, loteamento, morro, núcleo, parque, passarela, pátio, praça, quadra, recanto, residencial, rodovia, setor, sítio, travessa, trecho, trevo, vale, vereda, via, viaduto, viela, vila. 4. Remova o tipo de logradouro OUTROS. 5. Complete a relação de Unidades Federadas: AL, AP, BA, CE, DF, ES, GO, MA, MG, MS, PA, PB, PE, PI, PR, RN, RO, RR, RS, SC, SE, TO. 2.3 O Value Object Cliente Precisamos criar um JavaBean, também conhecido como Value Object ou Data Transfer Object, para armazenar os dados do cliente. Essa JavaBean será uma representação dos dados da tabela cliente, do nosso modelo. 1. Crie o pacote br.edu.univag.sisped.vo no projeto sisped; 2. Crie uma classe chamada Cliente Java no pacote acima; 3. Crie os atributos para fazer o mapeamento com os campos da tabela: private int cod; private String nome; private String cpf; private String telefone; private String ; private String cep; private TipoLogradouro tipologradouro; private String logradouro; private String numero; private String complemento; private String bairro; private String municipio; private TipoUnidadeFederada uf; 4. Adicione as importações necessárias (enum TipoLogradouro e TipoUnidadeFederada), usando o atalho de teclado <Ctrl> + <Shift> + i; 5. Acrescente os métodos acessores (getters e setters) para cada atributo, com a combinação de teclado <Alt> + <Insert>; 6. Pronto, os registros da tabela cliente agora podem ser utilizados na nossa aplicação. 2.4 Exercícios 1. Implemente o value object para a tabela fornecedor, criando uma classe chamada Fornecedor, no pacote br.edu.univag.sisped.vo, com os seguintes nomes de atributos: cod (int), nome (String), cnpj (String), telefone (String), fax (String), (String) e website (String). 2. Implemente um novo enum Java, chamado TipoUnidadeMedida, no pacote br.edu.univag.sisped.tipo, para ser usado como atributo da classe Produto. Pesquise quais são as unidades legais de medida (símbolo e nome) e implemente algumas. Para criar, siga os passos descritos na seção para criar TipoLogradouro e TipoUnidadeFederada. 3. Implemente o value object para a tabela produto, criando uma classe chamada Produto, no pacote br.edu.univag.sisped.vo, com os seguintes nomes de atributos: cod (int), fornecedor (Fornecedor), nome (String), descricao (String), unidademedida (TipoUnidadeMedida) e valorunitario (double). Observação: Em vez de ter 8

9 um atributo com o código do fornecedor, deve-se inserir uma referência para a classe Fornecedor, criada no primeiro exercício. 4. Implemente o value object para a tabela de itens de pedido, pedido_item, criando uma classe chamada PedidoItem, no pacote br.edu.univag.sisped.vo, com os seguintes nomes de atributos: produto (Produto) e quantidade (double). 5. Implemente um método chamado gettotal() na classe PedidoItem, calculando o total do item de pedido. 6. Implemente o value object para a tabela de pedido, criando uma classe chamada Pedido, no pacote br.edu.univag.sisped.vo, com os seguintes nomes de atributos: cod (int), cliente (Cliente), data (java.util.date) e itens (List<PedidoItem>). 9

10 Prática 3: Acessando o banco de dados Nesta prática conectaremos nossa aplicação com o banco de dados, onde serão inseridos, consultados, aterados e excluídos um conjunto de registros através de uma conexão usando driver JDBC para o banco de dados MySQL. 3.1 Classe utilitária para a conexão com o banco de dados Para centralizar a conexão com o banco de dados, se faz necessário criar uma classe utilitária para gerenciar a conexão com o banco de dados. Para um reaproveitamento melhor das implementações, recomenda-se criar um projeto específico para as classes utilitárias que podem ser reutilizadas e reaproveitadas em outros projetos. Na sequêcia de práticas a serem executadas, todos os arquivos serão mantidos em um único projeto Implementação da classe ConexaoBD A seguir vamos implementar uma classe de conexão com o banco de dados e também começaremos a criar as classes de teste unitário para verificarmos se a implementação está funcionando de fato. 1. Crie um novo pacote chamado br.edu.univag.util.sql, para as implementações que devem ficar em outros projetos, provendo a reutilização; 2. No pacote acima crie uma nova classe chamada ConexaoBD; 3. Para conectarmos com um banco de dados, precisamos saber qual é o driver de conexão a ser usado, a URL com o endereço do banco de dados, o usuário de banco de dados e a senha para efetuar o login, então acrescente os atributos necessários para armazenar estes dados: private final String driver; private final String url; private final String usuario; private final String senha; 4. Precisamos também de um atributo para referenciarmos a conexão criada e outro para o situação (conectado ou não): private Connection con; private boolean conectado; 5. Acrescente a importação da classe java.sql.connection, utilizando o atalho de teclado <CtrL>+<Shift>+<i>; 6. Crie um construtor, utilizando o atalho de teclado <Ctrl> + <Espaço>, de forma que os atributos driver, url, usuario e senha possam ser preenchidos. No caso, o Netbeans oferece auxílio apenas para o construtor default ou para para o construtor contendo todos os atributos, então selecione o segundo e remova o código que esteja sobrando: public ConexaoBD(String driver, String url, String usuario, String senha) { this.driver = driver; this.url = url; this.usuario = usuario; this.senha = senha; 7. Inclua, através do atalho de teclado <Ctrl>+<Espaço>, o método acessor get para o atributo conectado (note que não é oferecido o método getconectado e sim isconectado, essa é uma característica específica para os atributos do tipo boolean, pois possui uma semântica melhor em inglês); 8. Agora será necessário criar os métodos para se conectar e desconectar ao banco de dados: public void conectar() { Class.forName(this.driver); this.con = DriverManager.getConnection(url, usuario, senha); this.con.setautocommit(false); this.conectado = true; catch (ClassNotFoundException SQLException ex) { Logger.getLogger(ConexaoBD.class.getName()).log(Level.SEVERE, ex); this.conectado = false; public void desconectar() { null, 10

11 if (isconectado()) { this.con.rollback(); this.con.close(); this.conectado = false; catch (SQLException ex) { Logger.getLogger(ConexaoBD.class.getName()).log(Level.SEVERE, null, ex); 9. Adicione as importações necessárias (<Ctrl>+<Shift>+<i>); 10. Para podermos executar comandos SQL no banco de dados, precisamos criar objetos do tipo java.sql.preparedstatement. Adicionalmente, como as chaves primárias das nossas tabelas são geradas automaticamente, será necessário informar quando iremos ou não precisar obter as chaves geradas pelo banco de dados. Então, teremos dois métodos para executarmos os comandos SQL e um terceiro para obter o valor da chave gerada pelo banco de dados: public PreparedStatement prepararsql(string sql) throws SQLException { return prepararsql(sql, false); public PreparedStatement prepararsql(string sql, boolean gerarchaves) throws SQLException { if (isconectado()) { if (gerarchaves) { return con.preparestatement(sql, PreparedStatement.RETURN_GENERATED_KEYS); else { return con.preparestatement(sql, PreparedStatement.NO_GENERATED_KEYS); else { throw new SQLException("Não conectado ao banco de dados!"); public long getchave(preparedstatement ps) throws SQLException { long resposta = 0; try (ResultSet rs = ps.getgeneratedkeys()) { if (rs.next()) { resposta = rs.getlong(1); return resposta; 11. Adicione as importações necessárias (<Ctrl>+<Shift>+<i>); 12. No código-fonte acima, obtemos o valor da chave gerada através do método getgeneratedkeys(), da classe java.sql.preparedstatement e, adicionalmente precisamos da interface java.sql.resultset para tratarmos a resposta deste método; 13. Para finalizarmos, precisamos de um método para formatar o resultado de maneira que possa ser visualizada em uma tabela, quando construirmos a interface visual de uma consulta ao banco de dados: public DefaultTableModel gettabela(resultset rs) { DefaultTableModel tabela = new DefaultTableModel(); //Obtém os meta dados ResultSetMetaData rsmd = rs.getmetadata(); //Pega o número de colunas 11

12 int numcolunas = rsmd.getcolumncount(); //Cria um vetor para guardar o título das colunas String[] nomesdascolunas = new String[numColunas]; //Alimenta o vetor com os títulos das colunas for (int i = 0; i < numcolunas; i++) { nomesdascolunas[i] = rsmd.getcolumnlabel(i + 1); //Ajusta os títulos das colunas da tabela em função dos //dados do vetor tabela.setcolumnidentifiers(nomesdascolunas); while (rs.next()) { Object[] linha = new Object[numColunas]; for (int i = 0; i < numcolunas; i++) { linha[i] = rs.getobject(i + 1); tabela.addrow(linha); catch (SQLException ex) { Logger.getLogger(ConexaoBD.class.getName()).log(Level.SEVERE, ex); null, return tabela; 14. Adicione as importações necessárias (<Ctrl>+<Shift>+<i>); 15. Pronto, agora temos uma classe utilitária para banco de dados Driver JDBC para a conexão com o banco de dados Para se conectar com o banco de dados MySQL, será necessário incluir a biblioteca de conexão conhecida como MySQL Connector/J: 1. Clique com o botão direito em Bibliotecas, do seu projeto sisped, no Netbeans, acionando o comando Adicionar JAR/Pasta...; 2. Selecione o arquivo C:\mysql-connector-java \mysql-connector-java bin.jar; 3. Marque a opção Copiar para a Pasta de Bibliotecas; 4. Clique no botão OK Teste de Unidade da classe ConexaoBD Bom, até agora não testamos as classes que criamos. É sempre uma boa prática testarmos os códigos que criamos para termos a certeza de que estão funcionando, com o objetivo de aumentar a qualidade dos softwares desenvolvidos: 1. Acione o comando de menu Arquivo > Novo Arquivo...; 2. Na janela Novo Arquivo, vá para o campo Filtro, digitando teste; 3. Selecione o tipo de arquivo Teste para a Classe Existente; 4. Clique no botão Próximo; 5. Selecione a classe br.edu.univag.util.sql.conexaobd no campo Classe a Testar; 6. Clique no botão Finalizar; 7. Se for perguntado a versão do JUnit a ser utilizado, selecione a opção JUnit 4.x e confirme; 8. Note que agora o seu projeto possui mais dois elementos: Pacotes de Teste e Bibliotecas de Testes; 9. A classe de teste possui três seções: o construtor, as configurações para serem executadas antes e depois tanto da classe como de cada método, os testes para cada um dos métodos a ser avaliado; 10. Execute o teste (<Ctrl>+<F6>); 11. Note que ocorreram erros (diferente de falhar) nos testes, pois ainda precisam ser implementados para testarem cada um dos cenários adequadamente; 12. Primeiramente, crie um atributo estático para referenciar um objeto de ConexaoBD: private static ConexaoBD conbd; 12

13 13. O método setupclass é chamado apenas uma vez durante o tempo de vida da classe de teste, então é o local ideal para criarmos uma referência a um objeto public static void setupclass() { System.out.println("setUpClass"); String driver = "com.mysql.jdbc.driver"; String url = "jdbc:mysql://localhost/pedido"; String usuario = "root"; String senha = ""; conbd = new ConexaoBD(driver, url, usuario, senha); 14. Agora, podemos implementar o primeiro método de public void testisconectado() { System.out.println("isConectado"); ConexaoBD instance = ConexaoBDTest.conBD; boolean expresult1 = false; boolean result1 = instance.isconectado(); assertequals(expresult1, result1); instance.conectar(); boolean expresult2 = true; boolean result2 = instance.isconectado(); assertequals(expresult2, result2); instance.desconectar(); boolean expresult3 = false; boolean result3 = instance.isconectado(); assertequals(expresult3, result3); 15. Execute a classe de teste novamente e confira na janela Resultados do Teste que existe um teste aprovado; 16. Faça o mesmo o método para public void testconectar() { System.out.println("conectar"); ConexaoBD instance = ConexaoBDTest.conBD; instance.conectar(); boolean expresult = true; boolean result = instance.isconectado(); assertequals(expresult, result); 17. Faça o teste a cada implementação e contunue até o restante da classe de public void testdesconectar() { System.out.println("desconectar"); ConexaoBD instance = ConexaoBDTest.conBD; instance.desconectar(); boolean expresult = false; boolean result = instance.isconectado(); assertequals(expresult, public void testprepararsql_string() throws Exception { System.out.println("prepararSQL"); String sql = "show tables"; 13

14 ConexaoBD instance = conbd; instance.conectar(); try (PreparedStatement result = instance.prepararsql(sql)) { assertnotnull(result); public void testprepararsql_string_boolean() throws Exception { System.out.println("prepararSQL"); String sql = "show tables"; boolean gerarchaves = false; ConexaoBD instance = conbd; instance.conectar(); try (PreparedStatement result = instance.prepararsql(sql, gerarchaves)) { assertnotnull(result); public void testgetchave() throws Exception { System.out.println("getChave"); String sql = "show tables"; boolean gerarchaves = true; ConexaoBD instance = conbd; instance.conectar(); try (PreparedStatement ps = instance.prepararsql(sql, gerarchaves)) { long expresult = 0L; long result = instance.getchave(ps); assertequals(expresult, result); public void testgettabela() throws SQLException { System.out.println("getTabela"); String sql = "show tables"; ConexaoBD instance = conbd; instance.conectar(); try (PreparedStatement ps = instance.prepararsql(sql); ResultSet rs = ps.executequery()) { DefaultTableModel result = instance.gettabela(rs); assertnotnull(result); instance.desconectar(); 18. É lógico que alguns desses testes acima precisa melhorar em razão de não refletirem exatamente os cenários reais e não testarem adequadamente as situações que possam ocorrer Utilizando um arquivo de configuração (propriedades) Em vez de incluirmos os dados para o acesso ao banco de dados no código-fonte, mesmo que em uma classe utilitária única, é melhor incluir esses detalhes em uma configuração externa. Assim, é possível que utlizemos um banco de dados enquanto estamos desenvolvendo a aplicação e utilizemos outro banco de dados, com diferentes dados para ser acessado. E, além disso, não precisamos ficar recompilando toda vez que muda algum detalhe, como o driver, URL, usuário ou senha do banco de dados. 1. Acione o comando de menu Arquivo > Novo Arquivo...; 2. Na janela Novo Arquivo, selecione a categoria Outros e o tipo de arquivo Arquivo de Propriedades; 14

15 3. Clique no botão Próximo; 4. Informe conexao como o nome do arquivo; 5. Selecione a pasta src (um arquivo nomeado conexao.properties será criado no pacote default do projeto NetBeans); 6. Clique no Botão Finalizar; 7. Um arquivo de propriedades possui sempre um par contendo um identificador (chave) e um valor associado, portanto inclua os dados necessários no seu conteúdo: jdbc.driver = com.mysql.jdbc.driver jdbc.url = jdbc:mysql://localhost/pedido jdbc.usuario = root jdbc.senha = 8. Agora, precisamos ler o conteúdo do arquivo acima. Para isso crie uma classe utilitária chamada PropriedadesBD no pacote br.edu.univag.util.sql, removendo o modificador public, para que somente classes do mesmo pacote tenham acesso à esta classe; 9. Adicione os seguintes atributos constantes: public static final String DRIVER; public static final String URL; public static final String USUARIO; public static final String SENHA; 10. Note que os atributos não foram inicializados. É uma boa prática carregarmos apenas uma vez as propriedades sobre os dados da conexão, para evitarmos leituras demasiadas em um arquivo que quase não se altera. Caso o arquivo de propriedades seja alterado, podemos simplesmente reiniciar a aplicação. 11. Na classe PropriedadesBD, adicione um bloco de código estático, após os atributos estáticos, para podermos carregar as constantes apenas uma única vez quando a classe for carregada: static { Properties props = new Properties(); props.load(properties.class.getresourceasstream("/conexao.properties")); catch (IOException ex) { Logger.getLogger(PropriedadesBD.class.getName()).log(Level.SEVERE, null, ex); DRIVER = props.getproperty("jdbc.driver"); URL = props.getproperty("jdbc.url"); USUARIO = props.getproperty("jdbc.usuario"); SENHA = props.getproperty("jdbc.senha"); 12. Adicione as importações necessárias (<Ctrl>+<Shift>+<i>); 13. Altere a classe ConexaoBD, inserindo um novo construtor sem parâmetros (default) e carregando os dados através da classe PropriedadesBD: public ConexaoBD() { this.driver = PropriedadesBD.DRIVER; this.url = PropriedadesBD.URL; this.usuario = PropriedadesBD.USUARIO; this.senha = PropriedadesBD.SENHA; 14. Desta forma, temos uma maneira mais fácil de manter e atualizar os dados de conexão com o nosso banco de dados Exercícios 1. Por que os atributos driver, url, usuario e senha da classe ConexaoBD foram marcados com o modificador final? 2. Qual a finalidade da instrução this.con.setautocommit(false), encontrada no método conectar()? 3. Qual a finalidade da instrução this.con.rollback(), encontrada no método desconectar()? 4. Implemente o método commit() na classe ConexaoBD. 5. Pesquise sobre como efetuar testes usando o JUnit. Existem muitos artigos e tutoriais nas mais renomadas fontes. Uma rápida pesquisa no Google permite um bom aprofundamento, seguindos os exemplos encontrados. 6. Altere a classe ConexaoBDTest para que utilize o construtor default, utilizando o arquivo de propriedades. 15

16 Prática 4: Padrão de Projeto Data Access Object (DAO) Nesta prática construiremos a camada de persistência da aplicação. Para isso, usaremos o mapeamento obbjeto relacional através do padrão de projeto DAO. Para padronizar o comportamento das classes DAO, iremos criar uma classe abstrata, contendo a implementação de atributos e assinaturas dos métodos que devem ser implementados nas classes filhas. 1. Crie uma nova classe Java, chamada DAO, no pacote br.edu.univag.util.sql; 2. Adicione o modificador abstract entre as palavras-reservadas public e class; 3. Crie um atributo para manter uma referência a um objeto ConexaoBD: protected final ConexaoBD conbd; 4. Note que o atributo possui a visibilidade protected para que possa ser acessado pelas classes filhas; 5. Observe também que o atributo possui o modificador final, para que a referência não seja atualizada após ter sido inicializada e, por este motivo, é necessário que seja implementado um construtor inicializando este atributo; 6. Implemente o construtor inicializando o atributo: public DAO(ConexaoBD condb) { this.conbd = condb; 7. Agora, podemos criar as implementações das classes para fazer o mapeamento objeto-relacional. 4.1 Manipulando registros de clientes Para manipular os registros de cliente, precisamos montar as intruções SQL e enviá-las para o servidor. Para tanto, DAO para a tabela cliente 1. Para começarmos, crie um novo pacote, chamado br.edu.univag.sisped.dao; 2. No pacote acima, crie uma nova classe chamada ClienteDAO; 3. Acrescente extends DAO, na linha de declaração da classe para informar que estamos especializando a classe abstrata DAO; 4. Importe a classe DAO (<Ctrl>+<Shift>+<i>); 5. O compilador irá reclamar que está faltando o construtor definido na classe DAO, use o atalho de teclado <Alt>+<Enter> na linha da declaração da classe e selecione a opção Adicionar Construtor - ClienteDAO(ConexaoBD); 6. Note que a classe ConexaoBD foi importada automaticamente, veja como ficou a classe ClienteDAO: package br.edu.univag.sisped.dao; import br.edu.univag.util.sql.conexaobd; import br.edu.univag.util.sql.dao; public class ClienteDAO extends DAO { public ClienteDAO(ConexaoBD condb) { super(condb); 7. A nossa classe está pronta para começar a ser implementada; 8. Implemente o primeiro método, insert, conforme o código-fonte abaixo: public int insert(cliente cliente) throws SQLException { String sql = "insert into " + "cliente(clinome, clicpf, clitelefone, cli , cliendcep, " + "cliendtiplogradouro, cliendlogradouro, cliendnumero, " + "cliendcomplemento, cliendbairro, cliendmunicipio, clienduf) " + "values (?,?,?,?,?,?,?,?,?,?,?,?)"; PreparedStatement ps = null; ResultSet rs = null; ps = conbd.prepararsql(sql, true); 16

17 ps.setstring(1, cliente.getnome()); ps.setstring(2, cliente.getcpf()); ps.setstring(3, cliente.gettelefone()); ps.setstring(4, cliente.get ()); ps.setstring(5, cliente.getcep()); ps.setint(6, cliente.gettipologradouro().getcodigo()); ps.setstring(7, cliente.getlogradouro()); ps.setstring(8, cliente.getnumero()); ps.setstring(9, cliente.getcomplemento()); ps.setstring(10, cliente.getbairro()); ps.setstring(11, cliente.getmunicipio()); ps.setstring(12, cliente.getuf().getsigla()); int resposta = ps.executeupdate(); if (resposta == 1) { int cod = (int)conbd.getchave(ps); cliente.setcod(cod); return resposta; finally { if (rs!= null) { rs.close(); if (ps!= null) { ps.close(); 9. Adicione as importações necessárias (<Ctrl>+<Shift>+<i>); 10. A instrução SQL deve ser construída manualmente, mas o Netbeans pode auxiliar na construção das instruções SQL através da janela de Serviços, conforme visto em laboratório; 11. Continue a implementação com os métodos para alterar, excluir, consultar um cliente pelo código e obtenha uma listagem de todos os clientes Testando a tabela cliente Como visto anteriormente, é bom testarmos o código-fonte que construímos. Então, vamos testar o método para inserir registro de cliente no banco de dados: 1. Crie um novo teste a classe existente; 2. Selecione a classe br.edu.univag.sisped.dao.clientedao; 3. Clique no botão Finalizar; 4. Como iremos testar apenas a instrução insert, altere o nome da classe clicando com o botão direito do mouse e acionando o comando Refatorar > Renomear...; 5. Informe o novo nome como ClienteDAOInsertTest e clique em Refatorar; 6. Implemente o método testinsert(), conforme o código public void testinsert() throws Exception { System.out.println("insert"); ConexaoBD conbd = new ConexaoBD(); conbd.conectar(); Cliente cliente = new Cliente(); cliente.setnome("pato Donald"); cliente.setcpf(" "); cliente.settelefone("(65) "); cliente.set ("pato.donald@apatada.com.br"); cliente.setcep(" "); cliente.settipologradouro(tipologradouro.rua); 17

18 cliente.setlogradouro("das Margaridas"); cliente.setnumero("1313"); cliente.setcomplemento("quadra 13"); cliente.setbairro("lagoa dos Patos"); cliente.setmunicipio("patópolis"); cliente.setuf(tipounidadefederada.mt); ClienteDAO instance = new ClienteDAO(conBD); int expresult = 1; int result = instance.insert(cliente); assertequals(expresult, result); conbd.commit(); conbd.desconectar(); 7. Adicione as importações necessárias (<Ctrl>+<Shift>+<i>); 8. Execute a classe de teste (<Ctrl>+<F6>); 9. Confira na janela de Serviços a inserção do registro; 10. É importante continuar e desenvolver os testes para as demais operações para manter os registros de clientes, copiando a classe e gerando novas classes, uma para cada método a ser testado Exercícios 1. Efetue outros testes de inserção de registros, trocando os dados armazenados pela classe de teste. 2. Implemente os métodos para alterar, excluir, consultar, na classe ClienteDAO, conforme as assinaturas abaixo: public int update(cliente cliente) throws SQLException public int delete(int clicod) throws SQLException public Cliente select(int clicod) throws SQLException public List<Cliente> select() throws SQLException 3. Para cada um dos métodos acima, crie uma classe de teste (copie a classe ClienteDAOInsertTest e faça as devidas adequações), com os nomes que correspondam ao nome de classe e método testado: ClienteDAOUpdateTest, ClienteDAODeleteTest, ClienteDAOSelectTest, ClienteDAOSelectAllTest. 4. Os métodos da classe ClienteDAO estão listados abaixo: public int update(cliente cliente) throws SQLException { String sql = "update cliente set " + "clinome =?, clicpf =?, clitelefone =?, cli =?, " + "cliendcep =?, cliendtiplogradouro =?, cliendlogradouro =?, " + "cliendnumero =?, cliendcomplemento =?, cliendbairro =?, cliendmunicipio =?, clienduf =? " + "where clicod =?"; PreparedStatement ps = null; ps = conbd.prepararsql(sql); ps.setstring(1, cliente.getnome()); ps.setstring(2, cliente.getcpf()); ps.setstring(3, cliente.gettelefone()); ps.setstring(4, cliente.get ()); ps.setstring(5, cliente.getcep()); ps.setint(6, cliente.gettipologradouro().getcodigo()); ps.setstring(7, cliente.getlogradouro()); ps.setstring(8, cliente.getnumero()); ps.setstring(9, cliente.getcomplemento()); ps.setstring(10, cliente.getbairro()); ps.setstring(11, cliente.getmunicipio()); ps.setstring(12, cliente.getuf().getsigla()); ps.setint(13, cliente.getcod()); return ps.executeupdate(); finally { 18

19 if (ps!= null) { ps.close(); public int delete(int clicod) throws SQLException { String sql = "delete from cliente " + "where clicod =?"; PreparedStatement ps = null; ps = conbd.prepararsql(sql); ps.setint(1, clicod); return ps.executeupdate(); finally { if (ps!= null) { ps.close(); private Cliente getcliente(resultset rs) throws SQLException { Cliente resposta = new Cliente(); int indcampo = 0; resposta.setcod(rs.getint(++indcampo)); resposta.setnome(rs.getstring(++indcampo)); resposta.setcpf(rs.getstring(++indcampo)); resposta.settelefone(rs.getstring(++indcampo)); resposta.set (rs.getstring(++indcampo)); resposta.setcep(rs.getstring(++indcampo)); resposta.settipologradouro(tipologradouro.get(rs.getint(++indcampo))); resposta.setlogradouro(rs.getstring(++indcampo)); resposta.setnumero(rs.getstring(++indcampo)); resposta.setcomplemento(rs.getstring(++indcampo)); resposta.setbairro(rs.getstring(++indcampo)); resposta.setmunicipio(rs.getstring(++indcampo)); resposta.setuf(tipounidadefederada.get(rs.getstring(++indcampo))); return resposta; public Cliente select(int clicod) throws SQLException { String sql = "select " + "clicod, clinome, clicpf, clitelefone, cli , cliendcep, " + "cliendtiplogradouro, cliendlogradouro, cliendnumero, " + "cliendcomplemento, cliendbairro, cliendmunicipio, clienduf " + "from cliente " + "where clicod =?"; PreparedStatement ps = null; ResultSet rs = null; ps = conbd.prepararsql(sql); ps.setint(1, clicod); rs = ps.executequery(); Cliente resposta = null; if (rs.next()) { 19

20 resposta = getcliente(rs); return resposta; finally { if (rs!= null) { rs.close(); if (ps!= null) { ps.close(); public List<Cliente> select() throws SQLException { String sql = "select " + "clicod, clinome, clicpf, clitelefone, cli , cliendcep, " + "cliendtiplogradouro, cliendlogradouro, cliendnumero, " + "cliendcomplemento, cliendbairro, cliendmunicipio, clienduf " + "from cliente " + "order by clinome"; PreparedStatement ps = null; ResultSet rs = null; ps = conbd.prepararsql(sql); rs = ps.executequery(); ArrayList<Cliente> resposta = new ArrayList<>(); while (rs.next()) { resposta.add(getcliente(rs)); return resposta; finally { if (rs!= null) { rs.close(); if (ps!= null) { ps.close(); 5. Ao inserir o código acima, adicione as importações necessárias (<Ctrl>+<Shift>+<i>). 6. O método auxiliar getcliente foi criado para ser reutilizado, evitando a que tenham códigos duplicados. 7. Crie uma classe para o mapeamento objeto-relacional para a tabela fornecedor, chamada de FornecedorDAO. Crie também as classes de teste para verificar o funcionamento dos métodos da classe. 4.2 Manipulando registros de produtos Após criar a classe FornecedorDAO, podemos criar uma classe específica para a manipulação de produtos DAO para a tabela produto 1. Crie uma nova classe, chamada ProdutoDAO, no pacote br.edu.univag.sisped.dao; 2. Seguindo os passos para a criação das classes ClienteDAO e FornecedorDAO, implemente a classe ProdutoDAO: package br.edu.univag.sisped.dao; 20

21 import br.edu.univag.sisped.tipo.tipounidademedida; import br.edu.univag.sisped.vo.fornecedor; import br.edu.univag.sisped.vo.produto; import br.edu.univag.util.sql.conexaobd; import br.edu.univag.util.sql.dao; import java.sql.preparedstatement; import java.sql.resultset; import java.sql.sqlexception; import java.util.arraylist; import java.util.list; public class ProdutoDAO extends DAO { public ProdutoDAO(ConexaoBD condb) { super(condb); public int insert(produto produto) throws SQLException { String sql = "insert into " + "produto(forcod, pronome, prodescricao, prounimedida, " + "provalunitario) " + "values (?,?,?,?,?)"; PreparedStatement ps = null; ResultSet rs = null; ps = conbd.prepararsql(sql, true); ps.setint(1, produto.getfornecedor().getcod()); ps.setstring(2, produto.getnome()); ps.setstring(3, produto.getdescricao()); ps.setint(4, produto.getunidademedida().getcodigo()); ps.setdouble(5, produto.getvalorunitario()); int resposta = ps.executeupdate(); if (resposta == 1) { int cod = (int) conbd.getchave(ps); produto.setcod(cod); return resposta; finally { if (rs!= null) { rs.close(); if (ps!= null) { ps.close(); " public int update(produto produto) throws SQLException { String sql = "update produto set " + "forcod =?, pronome =?, prodescricao =?, prounimedida =?, + "provalunitario =? " + "where procod =?"; try (PreparedStatement ps = conbd.prepararsql(sql)) { ps.setint(1, produto.getfornecedor().getcod()); ps.setstring(2, produto.getnome()); 21

22 ps.setstring(3, produto.getdescricao()); ps.setint(4, produto.getunidademedida().getcodigo()); ps.setdouble(5, produto.getvalorunitario()); ps.setint(6, produto.getcod()); return ps.executeupdate(); public int delete(int procod) throws SQLException { String sql = "delete from produto " + "where procod =?"; try (PreparedStatement ps = conbd.prepararsql(sql)) { ps.setint(1, procod); return ps.executeupdate(); private Produto getproduto(resultset rs) throws SQLException { Produto resposta = new Produto(); int indcampo = 0; resposta.setcod(rs.getint(++indcampo)); int forcod = rs.getint(++indcampo); resposta.setnome(rs.getstring(++indcampo)); resposta.setdescricao(rs.getstring(++indcampo)); resposta.setunidademedida(tipounidademedida.get(rs.getint(++indcampo))); resposta.setvalorunitario(rs.getdouble(++indcampo)); FornecedorDAO fornecedordao = new FornecedorDAO(conBD); Fornecedor fornecedor = fornecedordao.select(forcod); resposta.setfornecedor(fornecedor); return resposta; public Produto select(int procod) throws SQLException { String sql = "select " + "procod, forcod, pronome, prodescricao, prounimedida, " + "provalunitario " + "from produto " + "where procod =?"; PreparedStatement ps = null; ResultSet rs = null; ps = conbd.prepararsql(sql); ps.setint(1, procod); rs = ps.executequery(); Produto resposta = null; if (rs.next()) { resposta = getproduto(rs); return resposta; finally { if (rs!= null) { 22

23 rs.close(); if (ps!= null) { ps.close(); public List<Produto> select() throws SQLException { String sql = "select " + "procod, forcod, pronome, prodescricao, prounimedida, " + "provalunitario " + "from produto " + "order by pronome"; PreparedStatement ps = null; ResultSet rs = null; ps = conbd.prepararsql(sql); rs = ps.executequery(); ArrayList<Produto> resposta = new ArrayList<>(); while (rs.next()) { resposta.add(getproduto(rs)); return resposta; finally { if (rs!= null) { rs.close(); if (ps!= null) { ps.close(); 3. Note que como os dados do fornecedor são referenciados em vez de se guardar o código do fornecedor, o método para recuperar os dados de um registro acaba fazendo uma consulta para obter os dados do fornecedor usando a classe FornecedorDAO. Caso haja necessidade de alta performance, esse tipo de consulta deve ser evitado Testando a tabela produto Crie uma classe de teste para testar todo o fluxo de manutenção de um registro de banco de dados: 1. Crie um novo Teste para a Classe Existente; 2. Selecione a classe br.edu.univag.sisped.dao.produtodao para testar; 3. Clique no botão Finalizar; 4. Para exercitarmos o fluxo completo, primeiramente precisamos armazenar o registro inserido no banco de dados, criando um atributo de classe: private static Produto produto; 5. Adicione as importações necessárias (<Ctrl>+<Shift>+<i>); 6. Adicionalmente, para evitarmos os trechos repetitivos de preparação de conexão, transação e mapeamento objeto-relacional, precisamos de mais dois atributos, um para tratar das conexões com o banco de dados (ConexaoBD) e outro para a integração com a camada de persistência: private ConexaoBD conbd; private ProdutoDAO produtodao; 7. Adicione as importações necessárias (<Ctrl>+<Shift>+<i>); 23

24 8. O método setup é chamado antes de cada método de teste, enquanto o método teardown é chamado após cada método de public void setup() { System.out.println("setUp"); conbd = new ConexaoBD(); conbd.conectar(); produtodao = new public void teardown() { System.out.println("tearDown"); conbd.commit(); conbd.desconectar(); 9. Agora, devemos implementar os métodos de teste em uma ordem em que possamos testar a implementação: package br.edu.univag.sisped.dao; import br.edu.univag.sisped.tipo.tipounidademedida; import br.edu.univag.sisped.vo.fornecedor; import br.edu.univag.sisped.vo.produto; import br.edu.univag.util.sql.conexaobd; import java.util.list; import org.junit.after; import org.junit.afterclass; import org.junit.before; import org.junit.beforeclass; import org.junit.test; import static org.junit.assert.*; public class ProdutoDAOTest { private static Produto produto; private ConexaoBD conbd; private ProdutoDAO produtodao; public ProdutoDAOTest() public static void setupclass() public static void teardownclass() public void setup() { System.out.println("setUp"); conbd = new ConexaoBD(); conbd.conectar(); produtodao = new ProdutoDAO(conBD); 24

25 @After public void teardown() { System.out.println("tearDown"); conbd.commit(); public void testinsert() throws Exception { System.out.println("insert"); FornecedorDAO fornecedordao = new FornecedorDAO(conBD); Fornecedor fornecedor = fornecedordao.select(1); produto = new Produto(); produto.setfornecedor(fornecedor); produto.setnome("arroz Tio Sam"); produto.setdescricao("arroz tipo agulhinha, descascado"); produto.setunidademedida(tipounidademedida.metro); produto.setvalorunitario(2.34); int expresult = 1; int result = produtodao.insert(produto); assertequals(expresult, public void testupdate() throws Exception { System.out.println("update"); produto.setnome("arroz Tio João"); produto.setdescricao("arroz tipo 1, agulhinha"); produto.setunidademedida(tipounidademedida.quilograma); produto.setvalorunitario(2.82); int expresult = 1; int result = produtodao.update(produto); assertequals(expresult, public void testselect_int() throws Exception { System.out.println("select por código"); int procod = produto.getcod(); Produto expresult = produto; Produto result = produtodao.select(procod); assertequals(expresult, public void testselect_0args() throws Exception { System.out.println("select todos"); List<Produto> result = produtodao.select(); 25

26 asserttrue(result.size() > public void testdelete() throws Exception { System.out.println("delete"); int procod = produto.getcod(); int expresult = 1; int result = produtodao.delete(procod); assertequals(expresult, result); 10. Utilize o assistente do Netbeans para criar os métodos equals e hashcode, selecionando todos os atributos, para cada um dos Value Objects ou JavaBeans (Cliente, Fornecedor, Produto, Pedido e PedidoItem), permitindo uma comparação do conteúdo dos objetos; Exercícios 1. Implemente a classe ProdutoDAO (será necessário implementar a classe FornecedorDAO antes), fazendo um teste a cada método criado. 2. Implemente a classe de testes a cada método (insert, update, delete, select) implementado na classe ProdutoDAO, incrementando aos poucos. 3. O enum Java TipoUnidadeMedida possui a seguinte implementação: package br.edu.univag.sisped.tipo; public enum TipoUnidadeMedida { LITRO(1, "l", "Litro"), METRO(2, "m", "Metro"), QUILOGRAMA(3, "kg", "Quilograma"), TONELADA(4, "t", "Tonelada"), UNIDADE(5, "un", "Unidade"); private final int codigo; private final String simbolo; private final String nome; private TipoUnidadeMedida(int codigo, String simbolo, String nome) { this.codigo = codigo; this.simbolo = simbolo; this.nome = nome; public int getcodigo() { return codigo; public String getsimbolo() { return simbolo; public String getnome() { return nome; public static TipoUnidadeMedida get(int codigo) { TipoUnidadeMedida resposta = null; 26