ALPOO_Atividade4

Prévia do material em texto

1 
 
Pro. Me. Elisangela Sato 2023/2oSem. 
 
ALPOO - Atividade 4 
Objetivo: Aplicar os conceitos de DAO e JDBC para substituir a camada 
de dados da aplicação por acesso ao banco de dados. 
 
1. Utilize o projeto criado na Atividade 3. 
2. Adicione as dependências de H2 Database SQL e Spring Data JPA SQL no 
arquivo do Maven (pom.xml): 
... 
 <dependency> 
 <groupId>com.h2database</groupId> 
 <artifactId>h2</artifactId> 
 <scope>runtime</scope> 
 </dependency> 
 
 <dependency> 
 <groupId>org.springframework.boot</groupId> 
 <artifactId>spring-boot-starter-data-jpa</artifactId> 
 </dependency> 
... 
 
3. Inclua as configurações para a geração automática do banco de dados no arquivo 
src/main/resources/application.properties: 
spring.datasource.url=jdbc:h2:D:/universidade 
spring.datasource.username=diretor 
spring.datasource.password=password 
 
spring.jpa.show-sql=true 
spring.jpa.generate-ddl=true 
spring.jpa.hibernate.ddl-auto=create-drop 
 
4. Inclua também alguns comandos SQL INSERT no arquivo 
src/main/resources/import.sql para popular automaticamente a tabela aluno: 
INSERT INTO aluno (nome, data_nascimento) VALUES ('Miguel Almeida', 
'2007-09-03'); 
INSERT INTO aluno (nome, data_nascimento) VALUES ('Helena Torres', '2005-
03-09'); 
 
 
2 
 
Pro. Me. Elisangela Sato 2023/2oSem. 
 
5. Inicie a aplicação e teste a conexão com o banco de dados: 
 
6. Crie o pacote db dentro de model: 
com.unip.universidade.model.bd 
 
7. Implemente a classe de conexão com o banco ConnectionFactory.java: 
package com.unip.universidade.model.bd; 
 
import java.io.IOException; 
import java.sql.Connection; 
import java.sql.DriverManager; 
import java.sql.SQLException; 
import java.util.Properties; 
 
public class ConnectionFactory { 
 private static final String CONFIG_FILE = "db.properties"; 
 private Properties properties; 
 
 public ConnectionFactory() { 
 properties = new Properties(); 
 try { 
 properties.load(getClass().getClassLoader().getResourceAsStre
am(CONFIG_FILE)); 
 } catch (IOException e) { 
 e.printStackTrace(); 
 } 
 } 
 
3 
 
Pro. Me. Elisangela Sato 2023/2oSem. 
 
 public Connection getConnection() throws SQLException { 
 return 
DriverManager.getConnection(properties.getProperty("db.url"), 
 properties.getProperty("db.username"), 
properties.getProperty("db.password")); 
 } 
} 
 
8. Crie o arquivo de propriedades src/main/resources/db.properties com as 
informações de conexão que a classe ConectionFactory irá usar: 
db.url=jdbc:h2:D:/universidade 
db.username=diretor 
db.password=password 
 
9. Modifique a classe Aluno.java para adicionar as anotações: 
@Entity 
@NoArgsConstructor 
@AllArgsConstructor 
public class Aluno { 
 @Id 
 @GeneratedValue(strategy = GenerationType.IDENTITY) 
 @Setter 
 @Getter 
 private int matricula; 
 @Getter 
 @Setter 
 private String nome; 
 @DateTimeFormat(pattern = "yyyy-MM-dd") 
 @Getter 
 @Setter 
 private Date dataNascimento; 
 
 public Aluno(String nome, Date dataNascimento) { 
 this.nome = nome; 
 this.dataNascimento = dataNascimento; 
 } 
} 
 
 
 
 
 
 
 
4 
 
Pro. Me. Elisangela Sato 2023/2oSem. 
 
10. Reinicie a aplicação e verifique se a tabela Aluno foi criada: 
 
11. Crie a interface AlunoDAO dentro do pacote com.unip.universidade.model: 
package com.unip.universidade.model; 
 
import java.util.List; 
 
public interface AlunoDAO { 
 public List<Aluno> listarAlunos(); 
} 
12. Crie a classe AlunoDAOImpl.java, dentro do pacote 
com.unip.universidade.model.db, que implementa o método listarAluno() de 
acordo com a interface AlunoDAO: 
package com.unip.universidade.model.bd; 
 
import java.sql.Connection; 
import java.sql.Date; 
import java.sql.PreparedStatement; 
import java.sql.ResultSet; 
import java.sql.SQLException; 
import java.sql.Statement; 
import java.util.ArrayList; 
import java.util.List; 
 
import org.springframework.stereotype.Component; 
 
import com.unip.universidade.model.Aluno; 
5 
 
Pro. Me. Elisangela Sato 2023/2oSem. 
 
import com.unip.universidade.model.AlunoDAO; 
 
@Component 
public class AlunoDAOImpl implements AlunoDAO { 
 ConnectionFactory connectionFactory; 
 
 public AlunoDAOImpl() { 
 connectionFactory = new ConnectionFactory(); 
 } 
 
 @Override 
 public List<Aluno> listarAlunos() { 
 List<Aluno> lista = new ArrayList<Aluno>(); 
 try { 
 Connection connection = connectionFactory.getConnection(); 
 Statement statement = connection.createStatement(); 
 ResultSet resultSet = statement.executeQuery("select * from 
aluno"); 
 
 while (resultSet.next()) { 
 lista.add(new Aluno(resultSet.getInt("matricula"), 
resultSet.getString("nome"), resultSet.getDate("data_nascimento"))); 
 } 
 connection.close(); 
 resultSet.close(); 
 statement.close(); 
 } catch (SQLException e) { 
 e.printStackTrace(); 
 } 
 return lista; 
 } 
} 
13. Na classe AlunoController.java, faça as modificações para listar os alunos: 
... 
@Controller 
public class AlunoController { 
 //private AlunoService alunoService; 
 private AlunoDAO alunoDAO; 
 
 @Autowired 
 //public AlunoController(AlunoService alunoService) { 
 public AlunoController(AlunoDAO alunoDAO) { 
 this.alunoDAO = alunoDAO; 
 } 
 
 @RequestMapping("/listaAlunos") 
6 
 
Pro. Me. Elisangela Sato 2023/2oSem. 
 
 public ModelAndView listarAlunos(@ModelAttribute("aluno") Aluno 
aluno) { 
 ModelAndView modelAndView = new ModelAndView("alunos"); 
 //modelAndView.addObject("listaDeAlunos", 
alunoService.listarAlunos()); 
 modelAndView.addObject("listaDeAlunos", alunoDAO.listarAlunos()); 
 modelAndView.addObject("aluno", new Aluno()); 
 return modelAndView; 
 } 
... 
14. Reinicie a aplicação e chame a aplicação pela URL 
http://localhost:8080/listaAlunos para ver o resultado semelhante ao mostrado 
abaixo: 
 
15. Faça as seguintes modificações para alterar um aluno: 
Na interface AlunoDAO.java inclua os métodos: 
 public Aluno pesquisarAluno(int matricula); 
 public boolean alterarAluno(Aluno aluno); 
 public boolean incluirAluno(Aluno aluno); 
 
Na classe AlunoDAOImp.java inclua os métodos pesquisarAluno(), 
incluirAluno() e alterarAluno(): 
 @Override 
 public Aluno pesquisarAluno(int matricula) { 
 Aluno alunoRetorno = null; 
 try { 
 Connection connection = connectionFactory.getConnection(); 
7 
 
Pro. Me. Elisangela Sato 2023/2oSem. 
 
 PreparedStatement preparedStatement = 
connection.prepareStatement("select * from aluno where matricula = ?"); 
 preparedStatement.setInt(1, matricula); 
 ResultSet resultSet = preparedStatement.executeQuery(); 
 
 resultSet.next(); 
 alunoRetorno = new Aluno(matricula, 
resultSet.getString("nome"), resultSet.getDate("data_nascimento")); 
 
 connection.close(); 
 preparedStatement.close(); 
 } catch (SQLException e) { 
 e.printStackTrace(); 
 } 
 return alunoRetorno; 
 } 
 
 @Override 
 public boolean incluirAluno(Aluno aluno) { 
 try { 
 Connection connection = connectionFactory.getConnection(); 
 PreparedStatement preparedStatement = 
connection.prepareStatement("insert into aluno (matricula, nome, 
data_nascimento) VALUES (?, ?, ?)"); 
 preparedStatement.setInt(1, aluno.getMatricula()); 
 preparedStatement.setString(2, aluno.getNome());preparedStatement.setDate(3, new 
Date(aluno.getDataNascimento().getTime())); 
 int retorno = preparedStatement.executeUpdate(); 
 connection.close(); 
 preparedStatement.close(); 
 if (retorno > 0) return true; 
 } catch (SQLException e) { 
 e.printStackTrace(); 
 } 
 return false; 
 } 
 
 @Override 
 public boolean alterarAluno(Aluno aluno) { 
 try { 
 Connection connection = connectionFactory.getConnection(); 
 PreparedStatement preparedStatement = 
connection.prepareStatement("update aluno set nome = ?, data_nascimento = 
? where matricula = ?"); 
 preparedStatement.setString(1, aluno.getNome()); 
 preparedStatement.setDate(2, new 
Date(aluno.getDataNascimento().getTime())); 
 preparedStatement.setInt(3, aluno.getMatricula()); 
8 
 
Pro. Me. Elisangela Sato 2023/2oSem. 
 
 int retorno = preparedStatement.executeUpdate(); 
 connection.close(); 
 preparedStatement.close(); 
 if (retorno > 0) return true; 
 } catch (SQLException e) { 
 e.printStackTrace(); 
 } 
 return false; 
 } 
Na classe AlunoController.java modifique o método selecionarAlunos() para: 
 @RequestMapping("/selecionaAluno") 
 public ModelAndView selecionarAlunos(@RequestParam("id") int 
matricula) { 
 System.out.println("buscando o aluno: " + matricula); 
 //Aluno aluno = alunoService.findAluno(matricula); 
 Aluno aluno = alunoDAO.pesquisarAluno(matricula); 
 
 ModelAndView modelAndView = new ModelAndView("alunos"); 
 //modelAndView.addObject("listaDeAlunos", 
alunoService.listarAlunos()); 
 modelAndView.addObject("listaDeAlunos", alunoDAO.listarAlunos()); 
 modelAndView.addObject("aluno", aluno); 
 return modelAndView; 
 } 
 
E o método salvarAluno() para: 
 @PostMapping("/salvaAluno") 
 public String salvarAluno(@ModelAttribute("aluno") Aluno aluno) { 
 //Aluno alunoTemp = alunoService.findAluno(aluno.getMatricula()); 
 Aluno alunoTemp = alunoDAO.pesquisarAluno(aluno.getMatricula()); 
 if (alunoTemp != null) { 
 //int idAlunoTemp = 
alunoService.listarAlunos().indexOf(alunoTemp); 
 //alunoService.listarAlunos().set(idAlunoTemp, aluno); 
 alunoDAO.alterarAluno(aluno); 
 } else 
 //alunoService.listarAlunos().add(aluno); 
 alunoDAO.incluirAluno(aluno); 
 return "redirect:/listaAlunos"; 
 } 
 
16. Teste a alteração. 
 
9 
 
Pro. Me. Elisangela Sato 2023/2oSem. 
 
17. Faça as modificações para excluir um aluno: 
Na interface AlunoDAO.java inclua o método: 
 public boolean excluirAluno(int matricula); 
 
Na classe AlunoDAOImp.java inclua o método excluirAluno(): 
 
 @Override 
 public boolean excluirAluno(int matricula) { 
 try { 
 Connection connection = connectionFactory.getConnection(); 
 PreparedStatement preparedStatement = 
connection.prepareStatement("delete from aluno where matricula = ?"); 
 preparedStatement.setInt(1, matricula); 
 int retorno = preparedStatement.executeUpdate(); 
 connection.close(); 
 preparedStatement.close(); 
 if (retorno > 0) return true; 
 } catch (SQLException e) { 
 e.printStackTrace(); 
 } 
 return false; 
 } 
 
Na classe AlunoController.java modifique o método excluirAlunos() para: 
 @RequestMapping("/removeAluno") 
 public String removerAluno(@RequestParam("id") int matricula) { 
 //Aluno alunoTemp = alunoService.findAluno(matricula); 
 //if (alunoTemp != null) { 
 //int idAlunoTemp = 
alunoService.listarAlunos().indexOf(alunoTemp); 
 //alunoService.listarAlunos().remove(idAlunoTemp); 
 //} 
 alunoDAO.excluirAluno(matricula); 
 return "redirect:/listaAlunos"; 
 } 
 
18. Por fim, teste a exclusão.