LAB 1: Programação em Java

Due date: Class 1 14/09

Classe 3 16/09
Classe E& 2 21/09
Classe 4 23/09

Exercício 1 (3 pontos)
Construa um formulário de website para usuários se registrarem e fazerem login/logout com código Java usando JSP + Servlet
+ JDBC + mySQL + DAO. Consulte [1] e o documento anexado no final.
Exercise 2 (3 mks)
Construa um aplicativo web em Java que gerencie uma coleção de livros com a funcionalidade básica: listar,
inserir, atualizar, deletar (ou operações CRUD - Criar, Ler, Atualizar e Deletar). Referir [2]
Exercício 3 (4 pontos)
Dada um conjunto de classes de uma livraria online: Cliente, Endereço, Conta, Livro, ListaDePedidos (uma lista
de livros que um cliente encomenda), Pedido.
1. Construa um diagrama de classes
2. Adicionar atributos
3. Usando DAO
4. Construir banco de dados MySQL para gerenciar livros, clientes, contas, pedidos
5. Fazendo uso do Exercício 1,2 para construir um site para o cliente com o seguinte
funcionalidades
Registrar
Login/out
Pesquisar (livros) para selecionar livros
Criar Pedido

References
[1] JSP Servlet JDBC MySQL CRUD. Disponível em:
[Link]
[Link]
[Link]
[Link]
[2][Link]
exemplo

1
Referências
1. Diagrama de classe UML e relacionamentos p. 2
2. JSP-Servlet-mySQL p. 6
Padrão de Design DAO pg. 26

Módulo 1: Diagrama de Classe UML e Relacionamentos

Pergunta:

Como podemos determinar classes ao desenvolver um sistema de software?

Quando: em qual fase do processo de software?

-Onde: O nome/atributos/métodos da classe será definido de onde?
Quem: quem participa dessas atividades?

Quantos relacionamentos entre classes em UML existem?

Given two classes A, B, how can we define a relationship between these two
aulas?
Há mais de um relacionamento entre duas classes? Se houver mais de um,
qual deve ser selecionado? A seleção depende do quê?
A relação de classe depende do processo de negócios?
Usando o padrão de design DAO (Objeto de Acesso a Dados) por quê?

Existem seis relacionamentos entre classes em um diagrama de classes UML:

Dependência

Associação

Agregação

Composição

2
Hereditariedade

Realização

As relações acima são lidas da seguinte forma:

Dependência: a classe A usa a classe B

Associação: a classe A associa-se com a classe B
Agregação: a classe A tem uma classe B
Composição: a classe A possui uma classe B
Herança : a classe B é uma classe A (ou a classe A é estendida pela classe B)
Realização: a classe B realiza a classe A (ou a classe A é realizada pela classe B)
A dependência/associação é representada quando uma referência a uma classe é passada como um método.
parâmetro para outra classe. Por exemplo, uma instância da classe B é passada para um método da classe A:

classe pública A {

public void fazerAlgo(B b) { }

Agregação: Se a classe A armazenasse a referência à classe B para uso posterior, teríamos uma diferente
relação chamada Agregação. Um exemplo mais comum e mais óbvio de Agregação seria
via setter injection:

classe públicaA {

privateB bb;

public voidsetB(B b) { bb = b; }

Composição: Agregação é a forma mais fraca de contenção de objetos (um objeto contém outros objetos).
A forma mais forte é chamada de Composição. Na Composição, o objeto contêiner é responsável pela
creation and life cycle of the contained object. Implementation of composition is of the following forms:

Primeiro, via inicialização de membro:

public classA {

privateB b = newB();

Em segundo lugar, através da inicialização do construtor:

classe pública A {

3
 privateB bb;

publicA() {

bb =newB();

}// construtor padrão

Terceiro, através da inicialização preguiçosa:

classe pública A {

privateB _b;

publicB getB() {

se(null== _b) {

_b =newB();

retornar_b;

}// getB()

Herança é uma relação bastante direta de se representar em Java:

classe pública A {

...

}// classe A

classe pública BextendsA {

....

}// classe B

A realização também é direta em Java e trata da implementação de uma interface:

interface pública A {

...

4
 }// interface A

classe pública B implementa A {

...

}// classe B

Apresentaremos três exemplos que são investigados em todos os módulos da disciplina A&D

Exemplo 1: Biblioteca

Exemplo 2: Livraria Online

Exemplo 3: Sistema de Registro de Disciplinas na Universidade

5
JSP Servlet JDBC MySQL CRUD
By Ramesh Fadatare

[Link]
Neste tutorial, estamos construindo um aplicativo web simples de Gestão de Usuários que gerencia um
coleção de usuários com a funcionalidade básica:
{"list":"listar","insert":"inserir","update":"atualizar","delete":"deletar","CURD operations":"operações CRUD","Create":"Criar","Read":"Ler"}

Você pode baixar o código fonte deste tutorial do meu repositório do GitHub e o link é
dado no final deste tutorial.
Principais tutoriais de JSP, Servlet e JDBC:
Tutorial de Servlets
Tutorial JSP
Tutorial JDBC 4.2
ConfiraConstruir aplicativo Todo usando JSP, Servlet, JDBC e MySQL.
Vamos desenvolver abaixo recursos básicos simples em nossa aplicação web de Gerenciamento de Usuários:

1. Criar um Usuário
2. Atualizar um Usuário

3. Delete a User
4. Recuperar um Usuário
5. Lista de todos os Usuários

O aplicativo se parece com isso:

Ferramentas e tecnologias utilizadas

JSP - 2.2 +
IDE - STS/Eclipse Neon.3
JDK - 1.8 ou superior

6
 Apache Tomcat - 8.5
JSTL - 1.2.1
API Servlet - 2.5
MySQL - [Link]

Development Steps

1. Crie um Projeto Web Dinâmico no Eclipse

2. Adicionar Dependências
3. Estrutura do Projeto
4. Configuração do Banco de Dados MySQL

5. Crie um JavaBean - [Link]

6. Criar um [Link]
7. Crie um [Link]
8. Criando Página JSP de Listagem de Usuários - [Link]
9. Crie uma Página de Formulário de Usuário - [Link]
10. Criando página JSP de erro
11. Implantação e Teste da Demostração do Aplicativo

Diagrama de Classe

Here is the class diagram of theUser Managementweb application that we are going to

desenvolver neste tutorial:

7
1. Criar um Projeto Web Dinâmico no Eclipse

Para criar um novo projeto Web dinâmico no Eclipse:

1. No menu principal selecione Arquivo > Novo > Projeto....

2. No assistente que se seguir, escolha Web > Projeto Web Dinâmico.

8
3. Clique em Avançar.

4. Enter project name as "jsp-servlet-jdbc-mysql-example";

5. Certifique-se de que o tempo de execução alvo esteja definido como Apache Tomcat com o suporte atualmente disponível.

versão.

2. Adicionar Dependências

Adicione o lançamento mais recente dos arquivos jar abaixo aolibpasta.

[Link]
[Link]
[Link]
[Link]

3. Estrutura do Projeto

Estrutura padrão de projeto para sua referência -

9
4. Configuração do Banco de Dados MySQL

Let's create a database named "demo" in MySQL. Now, create a users table using below DDL
script:

CRIAR BANCO DE DADOS 'demo';

USE demo;

criar tabelausuarios(
idint(3)NOT NULLAUTO_INCREMENT,
nomevarchar(120)NÃO NULO,
emailvarchar(220)NÃO NULO,
paísvarchar(120)
CHAVE PRIMÁRIA(id)
);

Você pode usar o Cliente de Linha de Comando MySQL ou a ferramenta MySQL Workbench para criar o

banco de dados. A tabela de usuários acima parece com:

10
5. Create a JavaBean - [Link]

Vamos criar umUsuárioclasse java para modelar uma entidade de usuário no banco de dados com o seguinte código:

[Link];

/**
* Usuá[Link]
* Esta é uma classe modelo que representa uma entidade Usuário
*@authorRamesh Fadatare
*
*/
classe pública Usuário {
protected int id;
protectedString name;
stringProtegido email;
protectedString country;

publicUser() {}

publicUser(Stringname, Stringemail, Stringcountry) {

super();
[Link]=name;
[Link]=email;
[Link]=country;
}

publicUser(intid, Stringname, Stringemail, Stringcountry) {

super();
[Link]=id;
[Link]=name;
[Link]=email;
[Link]=country;
}

public int getId() {

returnid;
}
public void setId(int id) {
[Link]=id;
}
publicStringgetName() {
returnname;
}
public voidsetName(Stringname) {
[Link]=name;
}
publicStringgetEmail() {
retornaremail;
}
public void setEmail(String email) {
[Link]=email;
}
publicStringgetCountry() {

11
 retornarpaís
}
public void setCountry(String country) {
[Link]=country;
}
}

6. Crie um [Link]

Vamos criar umUserDAOclasse que é uma classe de Camada de Acesso a Dados (DAO) que fornece CRUD
(Criar, Ler, Atualizar, Excluir) operações para a tabela de usuários em um banco de dados. Aqui está o código fonte completo

código doUserDAO:

[Link];

importar [Link];
[Link];
importar [Link];
importar [Link];
importar [Link];
importar [Link];
importar [Link];

[Link];

/**
* [Link] Esta classe DAO fornece operações CRUD de banco de dados para o
* tabela usuários no banco de dados.
*
*@authorRamesh Fadatare
*
*/
classe pública UserDAO{
privateString jdbcURL="jdbc:mysql://localhost:3306/demo?useSSL=false";
privateString jdbcUsername="root";
privateString jdbcPassword="root";

private static final String INSERT_USERS_SQL = "INSERT INTO users" + " (nome,
email, país) VALORES
" (?, ?, ?);";

private static final String SELECT_USER_BY_ID = "select id, nome, email, país"
de usuários onde id =?
private static final String SELECT_ALL_USERS = "select * from users";
private static finalStringDELETE_USERS_SQL="delete from users where id = ?;";
private static final String UPDATE_USERS_SQL = "atualizar usuários definir nome = ?, email =
?, país =? onde id = ?;

publicUserDAO() {}

12
 protectedConnectiongetConnection() {
Conexão conexão=null;
tente{
[Link]("[Link]");
connection=[Link](jdbcURL, jdbcUsername,
jdbcPassword);
}catch(SQLException e) {
// TODO Bloco de captura gerado automaticamente
[Link]();
} catch(ClassNotFoundException e) {
// TODO Bloco de captura gerado automaticamente
[Link]();
}
retornarconexão;
}

public voidinsertUser(Useruser)throwsSQLException {
[Link](INSERT_USERS_SQL);
// a declaração try-with-resource irá fechar a conexão automaticamente.
try(Connection connection=getConnection(); PreparedStatement
preparedStatement=[Link](INSERIR_USUÁRIOS_SQL)) {
[Link](1, [Link]());
[Link](2, [Link]());
[Link](3, [Link]());
[Link](preparedStatement);
[Link]();
}catch(SQLException e) {
printSQLException(e);
}
}

publicUserselectUser(intid) {
Usuário user=null;
// Passo 1: Estabelecendo uma Conexão
tente(Conexão conexão=getConnection();
// Passo 2: Criar uma declaração usando o objeto de conexão
PreparedStatement preparado=
[Link](SELECT_USER_BY_ID);
[Link](1, id);
[Link](preparedStatement);
// Passo 3: Execute a consulta ou atualize a consulta
ResultSet rs=[Link]();

// Etapa 4: Processar o objeto ResultSet.

enquanto([Link]()) {
String name=[Link]("name");
String email=[Link]("email");
String country=[Link]("country");
user= newUser(id, name, email, country);
}
}catch(SQLException e) {
printSQLException(e);
}
retornousuário;
}

13
 publicList < User >selectAllUsers() {

// usando try-with-resources para evitar fechar recursos (código boilerplate)

Lista<Usuario>usuarios= novaLista <>();
// Passo 1: Estabelecendo uma Conexão
tente(Conexão conexão=getConnection();

// Passo 2: Criar uma declaração usando o objeto de conexão

PreparedStatement preparedStatement=
[Link](SELECT_ALL_USERS);
[Link](preparedStatement);
// Passo 3: Execute a consulta ou atualize a consulta
ResultSet rs=[Link]();

// Passo 4: Processar o objeto ResultSet.

enquanto([Link]()) {
intid=[Link]("id");
String name=[Link]("name");
String email=[Link]("email");
String country=[Link]("country");
[Link](novoUsuario(id, nome, email, pais));
}
}catch(SQLException e) {
printSQLException(e);
}
retornousuários;
}

public boolean deleteUser(int id) throws SQLException {

linhaBooleanaDeletada;
tente(Connection connection=getConnection(); PreparedStatement statement=
[Link](DELETE_USERS_SQL);
[Link](1, id);
rowDeleted=[Link]()>0;
}
linhaDeletadaRetornada;
}

public boolean atualizarUsuario(User usuario) lança SQLException {

booleanrowAtualizado;
tente (Connection connection=getConnection(); PreparedStatement statement=
[Link](ATUALIZAR_USUÁRIOS_SQL);
[Link](1, [Link]());
[Link](2, [Link]());
[Link](3, [Link]());
[Link](4, [Link]());

rowUpdated=[Link]()>0;
}
linhaAtualizadaRetornada;
}

private voidprintSQLException(SQLExceptionex) {
para(Throwable e:ex) {
se(e instanceof SQLException) {

14
 [Link]([Link]);
[Link]("SQLState: " + ((SQLException) e).getSQLState());
[Link]("Código de Erro: " + ((SQLException)
e).getErrorCode());
[Link]("Mensagem: " + [Link]());
Throwable t=[Link]();
enquanto(t!=null) {
[Link]("Causa: " + t);
t=[Link]();
}
}
}
}
}

7. Crie um [Link]

Agora, vamos criarUserServletque atua como um controlador de página para lidar com todas as solicitações de
cliente. Vamos olhar o código primeiro:

[Link];

importar [Link];
importar [Link];
importar [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

[Link];
[Link];

/**
* [Link]
* Este servlet atua como um controlador de página para a aplicação, gerenciando todos
* pedidos do usuário.
*@emailRamesh Fadatare
*/

@WebServlet("/")
public class UserServlet extends HttpServlet {
privado estático final longserialVersionUID=1L;
privateUserDAO userDAO;

public void init() {

userDAO= newUserDAO();
}

15
 protegido void doPost(HttpServletRequest request, HttpServletResponse response)
throwsServletException, IOException {
doGet(solicitação, resposta);
}

protegido void doGet(HttpServletRequest request, HttpServletResponse response)

throwsServletException, IOException {
String action=[Link]();

tente{
switch(ação) {
case"/new":
showNewForm(request, response);
quebrar;
/inserir
insertUser(request, response);
quebrar;
case"/delete":
deleteUser(request, response);
quebrar;
caso"/editar":
mostrarFormularioEdicao(request, response);
quebrar;
case"/update":
atualizarUsuario(requisição, resposta);
interromper;
default:
listarUsuario(request, response);
quebra;
}
} catch (SQLException ex) {
lançar novaServletException(ex);
}
}

private voidlistUser(HttpServletRequestrequest, HttpServletResponseresponse)

throwsSQLException, IOException, ServletException {
List<User>listUser=[Link]();
[Link]("listUser", listUser);
RequestDispatcher dispatcher=[Link]("[Link]");
[Link](request, response);
}

private void mostrarNovaForma(HttpServletRequest pedido, HttpServletResponse resposta

response)
throwsServletException, IOException {
RequestDispatcher dispatcher=[Link]("[Link]");
[Link](request, response);
}

private voidshowEditForm(HttpServletRequestrequest, HttpServletResponse

response)
throwsSQLException, ServletException, IOException {
intid=[Link]([Link]("id"));
Usuário existingUser=[Link](id);

16
 RequestDispatcher dispatcher=[Link]("[Link]");
[Link]("user", existingUser);
[Link](request, response);

private void inserirUsuario(HttpServletRequest request, HttpServletResponse response)

lançaSQLException, IOException {
String name=[Link]("name");
String email=[Link]("email");
String country=[Link]("country");
Usuário newUser= newUser(nome, email, país);
[Link](newUser);
[Link]("list");
}

private void atualizarUsuario(HttpServletRequest request, HttpServletResponse response)

throwsSQLException, IOException {
intid=[Link]([Link]("id"));
String name=[Link]("name");
String email=[Link]("email");
String country=[Link]("country");

Usuário livro= novoUsuário(id, nome, e-mail, país);

[Link](livro);
[Link]("lista");
}

private void excluirUsuario(HttpServletRequest request, HttpServletResponse response)

throwsSQLException, IOException {
intid=[Link]([Link]("id"));
[Link](id);
[Link]("list");

}
}

8. Criando Página JSP de Listagem de Usuários - [Link]

Next, create a JSP page for displaying allusersfrom the database. Let's create alist-

[Link]ágina sob o diretório WebContent no projeto com o seguinte código:

<%@page language="java" contentType="text/html; charset=UTF-8"

pageEncoding="UTF-8"%
<%@taglib uri="[Link] prefix="c"%>
<html>

<head>

17
 <title>User Management Application</title>
<linkrel="stylesheet">
href="[Link]
integrity="sha384-ggOyR0iXCbMQv3Xipma34MD+dH/1fQ784/j6cY/iJTQUOhcWr7x9JvoRxT2MZw1T"
crossorigin="anônimo">
</head>

<body>

<header>
<nav class="navbar navbar-expand-md navbar-dark" style="background-
color:tomate">
<div>
<ahref="[Link]
Usuário
Aplicativo de Gestão </a>
</div>

<ulclass="navbar-nav">
<li><ahref="<%=[Link]()%>/list"class="nav-
link">Usuários</a></li>
</ul>
</nav>
</cabeçalho>
<br>

<divclass="row">
<!-- <div class="alert alert-success"
*ngIf='mensagem'>{{mensagem}}</div> -->

<divclass="container">
<h3 class="text-center">Lista de Usuários</h3>
<hr>
<div class="container text-left">

<ahref="<%=[Link]()%>/new"class="btn btn-
success">Add
Novo Usuário</a>
</div>
<br>
<table class="table table-bordered">
<thead>
<tr>
<th>ID</th>
<th>Nome</th>
<th>Email</th>
<th>Country</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
<!-- para (Todo todo: todos) { -->
<c:forEach var="user" items="${listUser}">

<tr>
<td>

18
 ${[Link]}
</td>
<td>
${[Link]}
</td>
<td>
<c:outvalue="${[Link]}"/>
</td>
<td>
${[Link]}
</td>
<td><ahref="edit?id=<c:out value='${[Link]}'
/>">Editar</a>&nbsp;&nbsp;&nbsp;&nbsp;<ahref="deletar?id=<c:out value='${[Link]}'
/>">Excluir</a></td>
</tr>
</c:forEach>
<!-- } -->
</tbody>

</table>
</div>
</div>
</body>

</html>

Uma vez que você implantar a página JSP acima no Tomcat e abrir no navegador, parecerá algo como

isto:

19
9. Crie uma Página JSP de Formulário de Usuário - [Link]

Em seguida, criamos uma página JSP para criar um novo Usuário [Link]. Aqui está sua fonte completa

code:

<%@página linguagem="java" tipoDeConteúdo="text/html; charset=UTF-8"

pageEncoding="UTF-8"%
<%@tagliburi="[Link]
<html>

<cabeça>
<title>User Management Application</title>
<linkrel="stylesheet"
href="[Link]
integrity="sha384-ggOyR0iXCbMQv3Xipma34MD+dH/1fQ784/j6cY/iJTQUOhcWr7x9JvoRxT2MZw1T"
crossorigin="anônimo">
</head>

<body>

<header>
<nav class="navbar navbar-expand-md navbar-dark" style="background-
cor:tomate">
<div>
<ahref="[Link]
Aplicativo de Gerenciamento de Usuários </a>

</div>

<ul class="navbar-nav">
<li><ahref="<%=[Link]()%>/list"class="nav-
link">Usuários</a></li>
</ul>
</nav>
</cabeçalho>
<br>
<div class="container col-md-5">
<divclass="card">
<divclass="card-body">
<c:iftest="${user!=null}">
<formaction="atualizar"method="post">
</c:if>
<c:iftest="${user==null}">
<form action="insert" method="post">
</c:if>

<caption>
<h2>
<c:iftest="${user!=null}">
Editar Usuário
</c:if>
<c:iftest="${user==null}">

20
 Add New User
</c:if>
</h2>
</caption>

<c:iftest="${user!=null}">
<input type="hidden" name="id" value="<c:out
value='${[Link]}' />"/>
</c:if>

<fieldset class="form-group">
<label>User Name</label> <inputtype="text"value="<c:out
value='${[Link]}' />"class="form-control"name="name"required="required">
</fieldset>

<fieldset class="form-group">
<label>User Email</label> <inputtype="text"
value="<c:out value='${[Link]}' />"class="form-control"name="email">
</fieldset>

<fieldsetclass="form-group">
<label>User Country</label> <inputtype="text"
value="<c:out value='${[Link]}' />"class="form-control"name="country">
</fieldset>

<buttontype="submit"class="btn btn-success">Save</button>
</form>
</div>
</div>
</div>
</body>

</html>

Uma vez que você implantar a página JSP acima no tomcat e abrir no navegador, parecerá algo como

isso:

21
A página acima atua para ambas as funcionalidades de criar um novo usuário e editar o mesmo usuário.

a página de edição parece:

22
10. Criando página JSP de Erro

Aqui está o código [Link]ágina que simplesmente mostra a mensagem de exceção:

<%@pagelanguage="java"contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8" isErrorPage="true"%
<!DOCTYPE html PUBLIC"-//W3C//DTD HTML 4.01 Transitional//EN"
[Link]
<html>
<cabeça>
<title>Error</title>
</cabeçalho>
<body>
<center>
<h1>Erro</h1>
<h2><%=[Link]() %><br/> </h2>
</centro>
</body>
</html>

11. Implementação e Teste da Aplicação

É hora de ver uma demonstração do aplicativo web de Gestão de Usuários acima. Implante este web
aplicação no servidor tomcat.

Digite a seguinte URL no seu navegador para acessar o usuário

Managementapplication:[Link]

Criar um novo usuário

23
Editar um Usuário

List of all Users

Repositório GitHub

O código-fonte deste tutorial (Gerenciamento de Usuários) está disponível no meu repositório do GitHub
em[Link]
ConfiraCriar aplicativo Todo usando JSP, Servlet, JDBC e MySQL.

24
Exemplos de Servlet + JSP + JDBC + MySQL
Exemplo de Servlet + JSP + JDBC + MySQL
Formulário de Registro usando JSP + Servlet + JDBC + Exemplo de Mysql
Formulário de Login usando JSP + Servlet + JDBC + Exemplo MySQL

25
 Padrão de Design DAO

[Link]

DAO significa Objeto de Acesso a Dados. DAOPadrão de Designé usado para separar a persistência de dados
lógica em uma camada separada. Dessa forma, o serviço permanece completamente no escuro sobre como o baixo-
as operações de nível para acessar o banco de dados são realizadas. Isso é conhecido como o princípio da Separação de
Lógica.

Com o padrão de design DAO, temos os seguintes componentes dos quais nosso design depende:

O modelo que é transferido de uma camada para outra.

Ointerfacesque oferece um design flexível.
A implementação da interface que é uma implementação concreta da lógica de persistência.

Implementando o padrão DAO

Com os componentes mencionados acima, vamos tentar implementar o padrão DAO. Usaremos 3
componentes aqui:

1. OLivromodelo que é transferido de uma camada para outra.

2. OBookDaointerface que fornece um design flexível e API para implementar.
[Link] concreta que é uma implementação doBookDaointerface.

Vamos colocar essa lógica em um diagrama:

26
Classe do modelo do Padrão DAO

Agora, vamos apresentar nosso objeto modelo.

[Link];

classe pública Livros {

private int isbn;

privateString bookName;

publicBooks(){
}

publicBooks(intisbn, String bookName){

[Link] = isbn;
[Link] = bookName;
}

// métodos getter e setter

}

É um objeto simples com apenas 2 propriedades para manter as coisas simples.

27
Interface do Padrão DAO

Vamos definir a interface para acessar os dados associados a ele no nível de persistência.

[Link];

[Link];

importar [Link];

interface pública BookDao {

List<Livros> obterTodosOsLivros();
Books getBookByIsbn(intisbn);
void saveBook(Books livro);
void deleteBook(Books livro);
}

Implementação do Padrão DAO

Em seguida, criamos uma classe concreta que implementa a interface acima.

[Link];

importar [Link];
importar [Link];

importar [Link];
importar [Link];

public classBookDaoImplimplementsBookDao {
//a lista está funcionando como um banco de dados
privateList<Livros> livros;

publicBookDaoImpl(){
books =newArrayList<>();
[Link](novosLivros(1,"Java"));
[Link](newBooks(2,"Python"));
[Link](newBooks(3,"Android"));
}

@Override
publicList<Livros> obterTodosLivros(){

28
 devolvers livros;
}

@Override
publicBooks getBookByIsbn(intisbn){
[Link](isbn);
}

@Override
public voidsaveBook(Books book){
[Link](livro);
}

@Override
public voiddeleteBook(Books book){
[Link](book);
}
}

Usando o Padrão DAO

Finalmente, colocamos esta implementação em uso no nosso método main():

[Link];

import [Link];
[Link];
[Link];

public class AccessBook {

public static void main(String[] args) {

BookDao bookDao = new BookDaoImpl();

for(Books livro : [Link]()) {

[Link]("ISBN do Livro : " +
[Link]());
}

//atualizar aluno
Livros book = [Link]().get(1);
[Link]("Algorithms");
[Link](livro);
}
}

29
 Vantagens do padrão DAO

Há muitas vantagens em usar o padrão DAO. Vamos listar algumas delas aqui:

1. Ao mudar um mecanismo de persistência, a camada de serviço não precisa nem saber onde o
os dados vêm de. Por exemplo, se você está pensando em mudar de MySQL para MongoDB,
todas as mudanças precisam ser feitas apenas na camada DAO.
2. O padrão DAO enfatiza o baixo acoplamento entre os diferentes componentes de uma aplicação. Então,
a camada de Visão não tem dependência da camada DAO e apenas a camada de Serviço depende dela, mesmo
que com as interfaces e não da implementação concreta.
3. Como a lógica de persistência é completamente separada, é muito mais fácil escrever testes unitários para componentes individuais.
componentes. Por exemplo, se você estiver usando JUnit e Mockito para frameworks de teste, será
fácil de simular os componentes individuais da sua aplicação.
4. Como trabalhamos com interfaces no padrão DAO, isso também enfatiza o estilo de "trabalhar com interfaces".
em vez de 'implementação', que é um excelente estilo de programação OOP.

EXEMPLO 2

classe pública Estudante{

privateStringnome;
private introllNo;

Aluno(String nome,intnumeroDeMatricula){
[Link]=name;
[Link]=rollNo;
}

publicStringgetName() {
returnname;
}

public void setName(String name) {

[Link]=name;
}

public int getRollNo() {

returnrollNo;
}

public void setRollNo(int rollNo) {

[Link]=rollNo;
}
}

30
Passo 2
importar [Link];

interface pública StudentDao{

publicList<Student>getAllStudents();
publicStudentgetStudent(introllNo);
public void atualizarEstudante(Estudante estudante);
public void deletarAluno(Student aluno);
}
importar [Link];
importar [Link];

public classStudentDaoImplimplementsStudentDao{

//a lista está funcionando como um banco de dados

Lista<Student>estudantes;

publicStudentDaoImpl(){
students=newArrayList<Student>();
estudante1=novoEstudante("Robert",0);
Studentstudent2=newStudent("John",1);
[Link](student1);
[Link](student2);
}
@Override
public void deleteStudent(Student student) {
[Link]([Link]());
[Link]("Estudante: Número de Registro " + [Link]()
+, excluído do banco de dados
}

//recuperar lista de alunos do banco de dados

@Override
publicList<Student>getAllStudents() {
retornar estudantes;
}

@Override
publicStudentgetStudent(introllNo) {
[Link](rollNo);
}

@Override
public void atualizarEstudante(Estudante estudante) {
[Link]([Link]()).setName([Link]());
[Link]("Estudante: Número de matrícula " + [Link]())
, atualizado no banco de dados
}
}

31
public class PadrãoDAOExemplo{
public static void main(String[] args) {
StudentDaostudentDao=newStudentDaoImpl();

//imprimir todos os alunos

para(Aluno aluno: [Link]()) {
[Link]("Estudante: [Matrícula : " +
[Link]() +", Name : "+[Link]() +" ]");
}

//atualizar aluno
Studentstudent=[Link]().get(0);
[Link]("Michael");
[Link](estudante);

//obter o estudante
[Link](0);
[Link]("Estudante: [Número de Registro : "+
[Link]() +", Nome : " + [Link]() + " ]";
}
}

32