Classe Aluno e Disciplina, Validação JUnit, gravação no MySql

Transcrição

1 Classe Aluno e Disciplina, Validação JUnit, gravação no MySql Criar um projeto -> Criar um pacote chamado entity. Criar uma classe Aluno contendo os atributos (idaluno, nome, , listadisciplina, cr, ativo), o relacionamento do Aluno com a classe Disciplina, o contrutor vazio, construtor cheio (sem os atributos: cr e ativo, pois serão calculados), construtor cheio(sem cr, ativo e relacionamento com a classe Disciplina), tostring, e getters e setters. package entity; import java.util.list; public class Aluno { private Integer idaluno; private String nome; private String ; private Double cr = 0.; private Boolean ativo; private List<Disciplina> listadisciplina; public Aluno() { public Aluno(Integer idaluno, String nome, String ) { super(); this.idaluno = idaluno; this.nome = nome; this. = ; public Aluno(Integer idaluno, String nome, String , List<Disciplina> listadisciplina) { super(); this.idaluno = idaluno; this.nome = nome; 1

2 this. = ; this.listadisciplina = public String tostring() { return "Aluno [idaluno=" + idaluno + ", nome=" + nome + ", =" + + ", listadisciplina=" + listadisciplina + ", cr=" + cr + "]"; public Integer getidaluno() { return idaluno; public void setidaluno(integer idaluno) { this.idaluno = idaluno; public String getnome() { return nome; public void setnome(string nome) { this.nome = nome; public String get () { return ; public void set (string ) { this. = ; public List<Disciplina> getlistadisciplina() { return listadisciplina; public void setlistadisciplina(list<disciplina> listadisciplina) { this.listadisciplina = listadisciplina; public Double getcr() { return cr; public void setcr(double cr) { this.cr = cr; public Boolean getativo() { return ativo; public void setativo(boolean ativo) { 2

3 this.ativo = ativo; Criar a classe de Disciplina com os atributos (código, disciplina, nota1, nota2, media, situacao) que se relacionará com a classe Aluno, colocar o relacionamento com o Aluno, construtor vazio, construtor cheio (sem os satributos a serem calculados), construtor cheio (sem os satributos a serem calculados e sem o relacionamento com a classe Aluno), tostring e getters e setters. package entity; public class Disciplina { private Integer codigo; private String disciplina; private Double nota1; private Double nota2; private transient Double media = 0.; private String situacao = ""; private Aluno aluno; public Disciplina() { public Disciplina(Integer codigo, String disciplina, Double nota1, Double nota2, Aluno aluno) { super(); this.codigo = codigo; this.disciplina = disciplina; this.nota1 = nota1; this.nota2 = nota2; this.aluno = aluno; public Disciplina(Integer codigo, String disciplina, Double nota1, Double nota2) { super(); this.codigo = codigo; 3

4 this.disciplina = disciplina; this.nota1 = nota1; this.nota2 = public String tostring() { return "Disciplina [codigo=" + codigo + ", disciplina=" + disciplina + ", nota1=" + nota1 + ", nota2=" + nota2 + ", media=" + media + ", situacao=" + situacao + "]"; public Integer getcodigo() { return codigo; public void setcodigo(integer codigo) { this.codigo = codigo; public String getdisciplina() { return disciplina; public void setdisciplina(string disciplina) { this.disciplina = disciplina; public Double getnota1() { return nota1; public void setnota1(double nota1) { this.nota1 = nota1; public Double getnota2() { return nota2; public void setnota2(double nota2) { this.nota2 = nota2; public Double getmedia() { return media; public void setmedia(double media) { this.media = media; public String getsituacao() { return situacao; public void setsituacao(string situacao) { 4

5 this.situacao = situacao; public Aluno getaluno() { return aluno; public void setaluno(aluno aluno) { this.aluno = aluno; Criar um pacote chamado control e criar uma classe ValidaAluno dentro desse pacote para a validação dos dados de Aluno. Serão criado métodos booleanos para validação campo a campo de cada atributo. package control; import java.util.regex.matcher; import java.util.regex.pattern; import entity.aluno; public class ValidaAluno { No método Booleano validacodigo passamos o parâmetro do Aluno e o objeto a, onde iremos verificar se o Id do Aluno é válido, passamos também o throws que se houver algum erro, o programa lançará uma exceção, um tipo de erro. Se o Id for menor ou igual a 0 (zero) gera um erro de exceção e imprime uma mensagem referente a esse erro, se não, se for válido, retorna verdadeiro. public Boolean validacodigo(aluno a) throws Exception { if (a.getidaluno() <= 0) { throw new IllegalArgumentException( "Codigo Invalido...Nao pode ser Nulo ou Negativo"); return true; 5

6 No método Booleano validanome passamos o parâmetro do Aluno a, onde iremos verificar se o nome é válido. Se o nome for nulo, gera um erro de exceção e uma mensagem, se o nome tiver tamanho igual a 0 (zero), ou seja vazio, também gera um erro e imprime mensagem. Se passar por essas validações passamos as regras. Chamamos a classe Pattern, responsável pelos padrões de regra e criamos um objeto. Através de Pattern chamamos o método compile e passamos a regra, o padrão a ser seguido. Na classe Matcher que pesquisará a regra também criamos um objeto e relacionamos esse o objeto da Pattern com a Matcher (padrão com pesquisa) e passamos que o parâmetro é o nome do Aluno. Se a pesquisa for diferente da regra gera um erro e uma mensagem, se não, dá true, o nome está dentro da regra. public Boolean validanome(aluno a) { if (a.getnome() == null){ throw new IllegalArgumentException("Nome nao pode ser NULL..."); if (a.getnome().length() == 0){ throw new IllegalArgumentException("Nome nao pode ser vazio..."); Pattern p = Pattern.compile("[A-Z a-z]{2,35"); Matcher m = p.matcher(a.getnome()); if (!m.matches()) { throw new IllegalArgumentException("Nome Invalido..."); return true; Para o método valida , chamaremos a classe Pattern, depois a classe Matcher. Se a pesquisa der diferente gera um erro e uma mensagem. Se não, retorna verdadeiro. public Boolean valida (aluno a) { Pattern p = Pattern.compile(".+@.+\\.[a-z]+"); Matcher m = p.matcher(a.get ()); if (!m.matches()) { throw new IllegalArgumentException(" Invalido..."); 6

7 return true; Para o método validacr, se o cr for menor que 0 (zero) ou maior que 10, gera um erro e imprime a mensagem, se não retorna verdadeiro. public Boolean validacr(aluno a) { if (a.getcr() < 0 a.getcr() > 10) { throw new IllegalArgumentException("Cr Invalido..."); return true; Para o método validaativo, se o aluno for diferente de ativo gera o erro com mensagem, se não, ele é ativo, verdadeiro. public Boolean validaativo(aluno a) { if (!a.getativo()) { throw new IllegalArgumentException("Aluno Inativo..."); return true; No main, iremos fazer os testes de validação dentro do bloco try e catch. Criamos um Aluno com seus dados. Passamos se ele está ativo e o valor do cr dele. Chamamos a classe de validação, ValidaAluno, criamos seu objeto e damos espaço de memória. Chamamos cada método para ser verificado. Imprimimos uma mensagem se tudo estiver correto e concatenamos com o tostring de Aluno. Se der errado, vai para o catch e imprime o erro. public static void main(string[] args) { try { Aluno a = new Aluno(10, "jose", "jose@gmail.com"); a.setativo(true); a.setcr(3.); ValidaAluno va = new ValidaAluno(); 7

8 va.validacodigo(a); va.valida (a); va.validanome(a); va.validaativo(a); va.validacr(a); System.out.println("Aluno Valido..." + a); catch (Exception ex) { System.out.println(ex.getMessage()); Criar uma classe Main para relacionar a classe Aluno com a classe Disciplina. O Aluno terá uma lista de disciplinas. Criar o método main para executar o teste. Criar um objeto aluno com seus dados(idaluno, nome, ). Relacionar o objeto de Aluno com setlistadisiciplina passando o ArrayList de Disicplina, que é o espaço para trabalharmos com essa lista. Chamar o objeto a de aluno e passar quais disciplina esse aluno possui através do método add, dar espaço para Disciplina e passar os dados dessa Disciplina(codigo, disciplina, nota1, nota2). 8

9 package entity; import java.util.arraylist; public class Main { public static void main(string[] args) { Aluno a = new Aluno(100, "pedro", "pedro@gmail.com"); a.setlistadisciplina(new ArrayList<Disciplina>()); a.getlistadisciplina().add(new Disciplina(10, "java", 3., 4.5)); a.getlistadisciplina().add(new Disciplina(11, "oracle",1., 2.)); Criar um for para calcular a media e a situação de quantas disciplinas o aluno tiver em sua lista. Dentro do for passar a classe Disciplina, criar um objeto para Disciplina e passar a lista que o aluno possui. O objeto de Disciplina passa o objeto de Aluno como parâmetro, depois chama setmedia onde passa a fórmula de cálculo da média e por último chama a situação passando a condição de aprovação ou reprovação. Por fim, imprime o objeto aluno com suas disciplinas já calculadas. for (Disciplina x : a.getlistadisciplina()) { x.setaluno(a); x.setmedia((x.getnota1() + x.getnota2()) / 2); x.setsituacao((x.getmedia() >= 6)? "aprovado" : "reprovado"); System.out.println(a); Resultado no console... Aluno [idaluno=100, nome=pedro, =pedro@gmail.com, listadisciplina=[disciplina [codigo=10, disciplina=java, nota1=3.0, nota2=4.5, media=3.75, situacao=reprovado], Disciplina [codigo=11, disciplina=oracle, nota1=1.0, nota2=2.0, media=1.5, situacao=reprovado]], cr=0.0] 9

10 Criar um pacote chamado test e criar uma classe chamada TestAluno. Para habilitar o teste utilizando o JUnit, clicar com o botão direito no projeto, clicar na aba Libraries e depois Add Library. 10

11 Próximo passo: Clicar em Junit e depois Next. Finish. 11

12 package test; import junit.framework.assert; import org.junit.before; import org.junit.test; import control.validaaluno; import entity.aluno; public class TestAluno { Criar o atributo da classe aluno e passar o objeto aluno. No método init será instanciando o objeto de aluno e seu espaço de memória. A indica que esse método será rodado primeiro que os outros métodos. private Aluno public void init(){ aluno = new Aluno(); 12

13 Criaremos um método de teste para impor as regras de nome. Pela indicamos que esse método é um teste que será executado depois do método com public void testquantidadelimitenome(){ aluno.setnome("aa"); Assert.assertTrue("Nome fora da faixa de 2 a 35", new ValidaAluno().validaNome(aluno)); Criaremos um outro método de teste para impor outras regras de public void testconteudonome(){ aluno.setnome(""); Assert.assertTrue("Nome não pode ter caracter especial", new ValidaAluno().validaNome(aluno)); Para testar a classe, clicar com o botão direito na classe, ir para Run as, depois JUnit Test. 13

14 Nesse teste, o exemplo usado não passou, deu resultado vermelho, isto é, foi pego no teste de verificação. No método testconteidonome estava vazio o campo nome. 14

15 Se modificarmos a classe teremos um novo resultado. package test; import junit.framework.assert; import org.junit.before; import org.junit.test; import control.validaaluno; import entity.aluno; public class TestAluno { private Aluno public void init(){ aluno=new public void testquantidadelimitenome(){ aluno.setnome("luciana"); Assert.assertTrue("Nome fora da faixa de 2 a 35", new public void testconteudonome(){ aluno.setnome("luciana"); Assert.assertTrue("Nome não pode ter caracter especial", new ValidaAluno().validaNome(aluno)); 15

16 Os nomes passados estão dentro das regras, então o resultado do teste ficou verde. Criando o banco de dados: Para criar o script do banco de dados, criar um pacote chamado persistence. Depois clicar no pacote, new e Other. 16

17 Depois SQL Development, SQL File e Next. 17

18 Em File name, colocar o nome do script e clicar em Next. Depois de criado o arquivo com o SQL do banco. Digitar os comando para criação do banco. Comandos: drop database if exists aula1; create database aula1; show databases; use aula1; show tables; Explicação: Apagar o banco se já existir com o nome de aula1. Criar um banco com o nome de aula1. Mostrar os bancos existentes na sua máquina. Usar o banco aula1. Mostrar as tabelas desse banco. 18

19 Copiar esses comandos para a janela do MySql. Criar no pacote persistence a classe Dao. Classe responsável pela conexão com o banco de dados. Todas as importações virão do pacote java.sql.* package persistence; import java.sql.callablestatement; import java.sql.connection; import java.sql.drivermanager; import java.sql.preparedstatement; import java.sql.resultset; public class Dao { Chamamos as classes de manipulação do banco onde Connection é responsável pela conexão com o banco, PreparedStatement responsável pelo acesso (gravar, alterar, excluir ou consultar) a tabela do banco, resultset pelas consultas com o comando select e CallableStatement pelas procedures. Connection con; PreparedStatement stmt; ResultSet rs; 19

20 CallableStatement call; Criamos um método para abertura do banco e conexão. Chamamos a classe Class e o método forname e passamos o diretório onde está o driver de conexão com o MySql. Pelo objeto con, chamamos a classe de gerenciamento dessa conexão e passamos o método de conexão getconnection com os parâmetros de conexão ao banco, usuário e senha. public void open() throws Exception{ Class.forName("com.mysql.jdbc.Driver"); con = DriverManager. getconnection("jdbc:mysql://localhost:3306/aula1","root","coti") ; Criamos um método para fecha a conexão com o banco. Passamos o objeto con e o método close. public void close() throws Exception{ con.close(); Criar um pacote chamado manager e uma classe ManagerBean para gerenciar a lista de disciplinas que a classe Aluno possui. Passar a classe Aluno como atributo e criar o objeto dele. package manager; import java.util.arraylist; import entity.aluno; import entity.disciplina; public class ManagerBean { 20

21 private Aluno aluno; Criar um construtor passando a classe Aluno como parâmetro e o objeto. Com a palavra reservada this, que faz referencia a própria classe e nesse caso, ao atributo aluno e passamos o objeto. Depois passaremos a lista de disciplinas para esse aluno. public ManagerBean(Aluno a) { this.aluno = a; this.aluno.setlistadisciplina(new ArrayList<Disciplina>()); public Aluno getaluno() { return aluno; Criar um método para adicionar as disciplinas, passar a classe Disciplina como parâmetro e o objeto. No corpo do método, charamr o objeto de aluno e relacionar com as disciplinas, já adicionando. public void add(disciplina d) { aluno.getlistadisciplina().add(d); No método main, chamamos a classe e depois um objeto e então damos espaço para trabalhar passando a criação de um novo aluno com seus dados. Passamos o objeto e em seguida o método add, adicionando as disciplina para o aluno. Pedimos para imprimir através do objeto e o getaluno. public static void main(string[] args) { ManagerBean mb = new ManagerBean(new Aluno(10, "stuart", "stuart@gmail.com")); mb.add(new Disciplina(10, "java", 1.2, 2.1)); mb.add(new Disciplina(11, "OCJA", 2.2, 2.4)); System.out.println(mb.getAluno()); 21

22 No console... Aluno [idaluno=10, nome=stuart, listadisciplina=[disciplina [codigo=10, disciplina=java, nota1=1.2, nota2=2.1, media=0.0, situacao=], Disciplina [codigo=11, disciplina=ocja, nota1=2.2, nota2=2.4, media=0.0, situacao=]], cr=0.0] 22