Para ajudar alguns alunos, estou disponibilizando a explicação sobre os comandos Switch e Enumeration em C.
A estrutura de switch consiste em uma série de rótulos case e um caso default opcional. O seguinte programa faz a contagem dos conceitos de aula baseados em uma grade (A, B, C, D, E).
#include <stdio.h> // Necessário para printf() e getchar().
int main()
{
char conceito;
int aContador = 0,
bContador = 0,
cContador = 0,
dContador = 0,
eContador = 0;
printf("Entre com os conceitos (A, B, C, D, E).\n");
printf("Para finalizar o processo de entrada utilizar um espaco.");
while ((conceito = getchar()) != ' ') {
switch (conceito) {
case 'A':
case 'a':
++aContador;
break;
case 'B':
case 'b':
++bContador;
break;
case 'C':
case 'c':
++cContador;
break;
case 'D':
case 'd':
++dContador;
break;
case 'E':
case 'e':
++eContador;
break;
case '\n': // Ignorar novas linhas e
case '\t': // tabs.
break;
default: // Todos os outros valores são tratados neste local.
printf("Letra incorreta para um conceito.\n");
printf("Entre com um novo conceito.");
break;
}
}
printf("Total de conceitos:");
printf("\nA: %d", aContador);
printf("\nB: %d", bContador);
printf("\nC: %d", cContador);
printf("\nD: %d", dContador);
printf("\nE: %d", eContador);
// Faz com que o programa espere digitar algo antes de sair.
scanf("\n");
return 0;
}
O usuário digita notas representadas por letras para uma turma. Dentro do cabeçalho do while a atribuição entre parênteses ((conceito = getchar()) != ‘ ‘) é executada primeiro. A função getchar() faz a leitura de um caractere do teclado e armazena na variável inteira conceito. Quando o caractere é um espaço o programa é finalizado. Ao entrar com outros caracteres os conceitos são contabilizados. Ao final esta contagem é exibida.
A palavra switch é seguida pelo nome da variável conceito entre parênteses. Isto é chamado de expressão de controle. O valor desta expressão é comparado com cada um dos rótulos case. O comando break faz com que o controle do programa passe para o primeiro comando depois da estrutura switch. O comando break é usado porque, caso contrário, os cases em um switch seriam executados juntos. Se break não for usado em algum lugar em uma estrutura switch, então toda vez que ocorrer uma igualdade, ou correspondência, na estrutura, os comandos para todos os casos restantes serão executados. (Essa característica às vezes é útil quando se quer executar as mesmas ações para vários cases). Se nenhuma correspondência ocorrer, o caso default é executado e é impressa uma mensagem de erro.
A figura a seguir mostra o fluxo básico do comando switch.
Os comandos break e continue alteram o fluxo de controle. O comando break, quando executado em uma estrutura while, for, do/while ou switch, provoca a saída imediata da estrutura. A execução do programa continua com o primeiro comando depois da estrutura. Os usos mais comuns do comando break são sair antecipadamente de um laço ou saltar o restante de uma estrutura switch. O seguinte programa demonstra o uso do comando break.
#include <stdio.h>
int main()
{
int x;
for (x = 1; x <= 10; x++) {
if (x == 5)
break;
printf("%d ", x);
}
printf("\nFinalizou o laco FOR com o valor de x = %d.\n", x);
scanf("\n");
return 0;
}
O comando break em uma estrutura de repetição for. Quando a estrutura if descobre que x se tornou 5, o break é executado. Isto torna o comando for e o programa continua com o printf depois do for. O laço é executado completamente só quatro vezes.
Note que a variável de controle x neste programa é definida fora do cabeçalho da estrutura for. Isto porque pretendemos usar a variável de controle tanto no corpo do laço como depois do laço completar sua execução.
O comando continue, quando executado em uma estrutura while, for ou do/while, salta os comandos restantes no corpo dessa estrutura e prossegue com a próxima repetição do laço. Em estruturas while e do/while, o teste de continuação do laço é feito logo depois do comando continue ser executado. Na estrutura for, a expressão de incremento é executada e então é feito o teste de continuação do laço. Anteriormente, declaramos que a estrutura while pode ser usada na maioria dos casos para representar a estrutura for. A única exceção ocorre quando a expressão de incremento na estrutura while vem após o comando continue. Neste caso, o incremento não é executado antes da condição de repetição/continuação ser testada e o while não executado da mesma maneira que o for. O seguinte programa usa o comando continue em uma estrutura for para saltar o comando de saída na estrutura e começar a próxima repetição do laço.
#include <stdio.h>
int main()
{
int x;
for (x = 1; x <= 10; x++) {
if (x == 5)
continue;
printf("%d ", x);
}
printf("\nUsando continue para pular a impressao do valor 5.\n");
scanf("\n");
return 0;
}
Jogo Craps
Um dos jogos de azar mais populares é um jogo de dados conhecido como craps, que é jogado em cassinos e salas de jogos de todo o mundo. As regras do jogo são simples:
Um jogador joga dois dados. Cada dado tem seis faces. Essas faces contêm 1, 2, 3, 4, 5 ou 6 pontos. Depois de os dados pararem, a soma dos pontos nas faces superiores é calculada. Se a soma for 7 ou 11 no primeiro lançamento, o jogador vence. Se a soma for 2, 3 ou 12 no primeiro lançamento (chamado craps) o jogador perde (i.e., a “banca” vence). Se a soma for 4,5, 6, 8, 9 ou 10 no primeiro lançamento, esta soma se torna o “ponto” do jogador. Para vencer, você deve continuar lançando os dados até “fazer seu ponto”. O jogador perde se tirar um 7 antes de fazer o ponto.
#include <stdio.h>
int rolarDados(void);
int main()
{
int soma, meusPontos;
int statusDoJogo; // 0 = Ganhou
// 1 = Perdeu
// 2 = Continue
srand(time(0));
soma = rolarDados();
switch (soma) {
case 7:
case 11:
statusDoJogo = 0;
break;
case 2:
case 3:
case 12:
statusDoJogo = 1;
break;
default:
statusDoJogo = 2;
meusPontos = soma;
printf("Os pontos sao %d\n", meusPontos);
break;
}
while (statusDoJogo == 2) {
soma = rolarDados();
if (soma == meusPontos) {
statusDoJogo = 0;
} else if (soma == 7) {
statusDoJogo = 1;
}
}
if (statusDoJogo == 0) {
printf("O jogador ganhou!\n");
} else {
printf("O jogador perdeu!\n");
}
scanf("\n");
return 0;
}
int rolarDados(void)
{
int dado1, dado2, somaDosDados;
dado1 = 1 + rand() % 6;
dado2 = 1 + rand() % 6;
somaDosDados = dado1 + dado2;
printf("Jogador jogando dado %d + %d = %d\n", dado1, dado2, somaDosDados);
return somaDosDados;
}
Observe que o jogador deve lançar dois dados no primeiro lançamento e deve fazer isso em todos os lançamentos subsequentes. Definimos uma função rolarDados para lançar os dados e calcular e imprimir a soma dos pontos de suas faces. A função rolarDados é definida apenas uma vez, mas é chamada em dois locais no programa. É interessante observar que rolarDados é definida apenas uma vez, mas é chamada em dois locais no programa. É interessante observar que rolarDados não recebe argumentos, portanto indicamos void na lista de parâmetros. A função rolarDados retorna a soma dos dois dados; assim, um tipo de retorno int é indicado no cabeçalho da função.
O jogo é razoavelmente complicado. O jogador pode vencer ou perder no primeiro lançamento ou pode vencer ou perder em qualquer lançamento subsequente. A variável statusDoJogo é usada para controlar isso.
Na variável statusDoJogo podemos usar o conceito de Enumerations em vez de valores inteiros. Isso torna o programa mais claro e evita possíveis erros. A seguir é apresentado este mesmo programa usando Enumerations.
#include <stdio.h>
int rolarDados(void);
enum Status {
CONTINUAR,
GANHOU,
PERDEU
};
int main()
{
int soma, meusPontos;
int statusDoJogo;
srand(time(0));
soma = rolarDados();
switch (soma) {
case 7:
case 11:
statusDoJogo = GANHOU;
break;
case 2:
case 3:
case 12:
statusDoJogo = PERDEU;
break;
default:
statusDoJogo = CONTINUAR;
meusPontos = soma;
printf("Os pontos sao %d\n", meusPontos);
break;
}
while (statusDoJogo == CONTINUAR) {
soma = rolarDados();
if (soma == meusPontos) {
statusDoJogo = GANHOU;
} else if (soma == 7) {
statusDoJogo = PERDEU;
}
}
if (statusDoJogo == GANHOU) {
printf("O jogador ganhou!\n");
} else {
printf("O jogador perdeu!\n");
}
scanf("\n");
return 0;
}
int rolarDados(void)
{
int dado1, dado2, somaDosDados;
dado1 = 1 + rand() % 6;
dado2 = 1 + rand() % 6;
somaDosDados = dado1 + dado2;
printf("Jogador jogando dado %d + %d = %d\n", dado1, dado2, somaDosDados);
return somaDosDados;
}
A linha enum Status { CONTINUAR, GANHOU, PERDEU }; cria um tipo definido pelo usuário chamado de enumeração. Uma enumeração, introduzida pela palavra-chave enum e seguida por um nome de tipo (neste caso Status), é um conjunto de constantes inteiras representadas por identificadores. Os valores destas constantes de enumeração começam em 0, a menos que especificado de outra forma, e são incrementados por 1. Na enumeração crescente, CONTINUAR recebe o valor 0, GANHOU, o valor 1 e PERDEU, o valor 2. Os identificadores em uma enum devem ser únicos; no entanto, constantes de enumeração separadas podem ter o mesmo valor inteiro.
Variáveis do tipo Status definidas pelo usuário somente podem receber a atribuição de um dos três valores definidos na enumeração. Quando o jogo é vencido, statusDoJogo recebe o valor GANHOU. Quando o jogo é perdido, statusDoJogo recebe o valor PERDEU. Caso contrário, statusDoJogo recebe o valor CONTINUAR, de maneira que os dados possam ser lançados novamente.
Depois do primeiro lançamento, se o jogo terminar, a estrutura while é ignorada porque statusDoJogo não será igual a CONTINUAR. O programa prossegue para a estrutura if/else que imprime “Jogador ganhou” se statusDoJogo for igual a GANHOU e “Jogador perde” se statusDoJogo for igual a PERDEU.
Depois do primeiro lançamento, se o jogo não terminar, a soma (soma) é armazenada na variável meusPontos. A execução prossegue com a estrutura while porque statusDoJogo é 0. Cada vez que a estrutura while é percorrida, rolarDados é chamada para produzir uma nova variável soma. Se soma for igual a meusPontos, statusDoJogo é definido com o valor GANHOU para indicar que o jogador ganhou, a condição no while torna-se falta, a estrutura if/else imprime “Jogador ganhou” e a execução termina. Se soma for igual a 7, statusDoJogo é definido com o valor PERDEU para indicar que o jogador perdeu, a condição no while torna-se falsa, o comando if/else imprime “Jogador perdeu” e a execução é encerrada.
Uma outra enumeração popular é
enum Meses { JAN = 1, FEV, MAR, ABR, MAI, JUN, JUL, AGO, SET, OUT, NOV, DEZ };
que cria um tipo definido pelo usuário chamado Meses com constantes de enumeração representando os meses do ano. Como o primeiro valor na enumeração precedente é inicializado explicitamente com 1, os demais são incrementados por 1, resultando nos valores 1 a 12. Qualquer constante de enumeração pode ter atribuído a ela um valor inteiro na definição da enumeração e cada uma das constantes de enumeração subsequentes terão um valor que é 1 e mais que a constante precedente.
Até mais a todos, abraços.
Aew pessoal, este será o nosso penúltimo post sobre Introdução ao Hibernate.
Nossa interface é muito simples e é composta apenas de uma janela com um grid mostrando informações de categorias. O grid é representado pelo componente JTable e está dentro de um panel. Este elemento é mostrado a seguir com a classe de CategoryGridPanel.
package br.com.branquinho.hibernate.application.gui;
import java.awt.BorderLayout;
public class CategoryGridPanel extends JPanel {
private static final long serialVersionUID = -3127985955124406559L;
private final JTable table;
private final DefaultTableModel tableModel;
/**
* Create the panel.
*/
public CategoryGridPanel() {
String[] columnNames = new String []{ "ID", "Name", "Description"};
this.tableModel = new DefaultTableModel(columnNames, 0);
setLayout(new MigLayout("", "[grow][grow]", "[grow][grow]"));
this.table = new JTable(this.tableModel);
this.table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
this.table.setCellSelectionEnabled(true);
add(this.table, "cell 0 0 2 2,grow");
add(this.table.getTableHeader(), BorderLayout.NORTH);
}
public void addCategoryRow(CategoryBean category) {
this.tableModel.addRow(new String[] {
String.valueOf(category.getId()),
category.getName(),
category.getDescription() });
}
}
Nossa janela é representada pela classe HibernateApplicationWindow, apresentada a seguir.
package br.com.branquinho.hibernate.application.gui;
import java.awt.EventQueue;
public class HibernateApplicationWindow {
private JFrame frmHibernateSample;
private static final IServicesFactory serviceFactory = new ServicesFactory();
/**
* Launch the application.
*/
public static void main(String[] args) {
EventQueue.invokeLater(new Runnable() {
@Override
public void run() {
try {
HibernateApplicationWindow window = new HibernateApplicationWindow();
window.frmHibernateSample.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}
/**
* Create the application.
*/
public HibernateApplicationWindow() {
initialize();
}
/**
* Initialize the contents of the frame.
*/
private void initialize() {
this.frmHibernateSample = new JFrame();
this.frmHibernateSample.setTitle("Hibernate Sample");
this.frmHibernateSample.setBounds(100, 100, 800, 600);
this.frmHibernateSample.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.frmHibernateSample.getContentPane().setLayout(new GridLayout(1, 0, 0, 0));
CategoryGridPanel categoryGridPanel = new CategoryGridPanel();
this.frmHibernateSample.getContentPane().add(categoryGridPanel);
loadCategories(categoryGridPanel);
}
private void loadCategories(CategoryGridPanel categoryGridPanel) {
List<CategoryBean> categories = serviceFactory.getCategoryService().findAllCategories();
for (CategoryBean category : categories) {
categoryGridPanel.addCategoryRow(category);
}
}
}
O resultado final de nossa aplicação é mostrado na figura e nos vídeos a seguir.
Vídeo 13
Vídeo 14
No próximo e último post irei falar um pouco sobre o resultado final de nosso trabalho.
Ficamos por aqui, até amanhã a todos.
Neste post continuarei a criação do ParserDatabase e dos testes dos serviços.
A classe ParserDatabase é usada apenas para transformar Entidades para Beans e vice-versa. A seguir é mostrada a implementação deste ParserDatabase.
package br.com.branquinho.hibernate.database.utils;
import java.util.ArrayList;
import java.util.List;
import br.com.branquinho.hibernate.database.entities.CategoryEntity;
import br.com.branquinho.hibernate.database.entities.ProductEntity;
import br.com.branquinho.hibernate.utils.database.beans.CategoryBean;
import br.com.branquinho.hibernate.utils.database.beans.ProductBean;
public class ParserDatabase {
public static CategoryEntity parserBeanToEntity(CategoryBean categoryBean) {
CategoryEntity categoryEntity = new CategoryEntity();
// ID
categoryEntity.setId(categoryBean.getId());
// Description
categoryEntity.setDescription(categoryBean.getDescription());
// Name
categoryEntity.setName(categoryBean.getName());
// Products
List<ProductEntity> products = parseProductBeansToEntities(categoryBean.getProducts());
categoryEntity.setProducts(products);
return categoryEntity;
}
public static ProductEntity parserBeanToEntity(ProductBean productBean) {
ProductEntity product = new ProductEntity();
// ID
product.setId(productBean.getId());
// Description
product.setDescription(productBean.getDescription());
// Price
product.setPrice(productBean.getPrice());
// Category
CategoryEntity category = parserBeanToEntity(productBean.getCategory());
product.setCategory(category);
return product;
}
public static List<ProductEntity> parseProductBeansToEntities(List<ProductBean> productsBean) {
List<ProductEntity> productsEntity = new ArrayList<ProductEntity>();
if (productsBean != null) {
for (ProductBean product : productsBean) {
productsEntity.add(parserBeanToEntity(product));
}
}
return productsEntity;
}
public static List<CategoryEntity> parseCategoryBeansToEntities(List<CategoryBean> categoriesBean) {
List<CategoryEntity> categoriesEntity = new ArrayList<CategoryEntity>();
if (categoriesBean != null) {
for (CategoryBean category : categoriesBean) {
categoriesEntity.add(parserBeanToEntity(category));
}
}
return categoriesEntity;
}
public static CategoryBean parserEntityToBean(CategoryEntity categoryEntity) {
CategoryBean categoryBean = new CategoryBean();
// ID
categoryBean.setId(categoryEntity.getId());
// Description
categoryBean.setDescription(categoryEntity.getDescription());
// Name
categoryBean.setName(categoryEntity.getName());
// Products
List<ProductBean> products = parseProductEntitiesToBeans(categoryEntity.getProducts());
categoryBean.setProducts(products);
return categoryBean;
}
public static ProductBean parserEntityToBean(ProductEntity productEntity) {
ProductBean productBean = new ProductBean();
// ID
productBean.setId(productEntity.getId());
// Description
productBean.setDescription(productEntity.getDescription());
// Price
productBean.setPrice(productEntity.getPrice());
// Category
productBean
.setCategory(parserEntityToBean(productEntity.getCategory()));
return productBean;
}
public static List<ProductBean> parseProductEntitiesToBeans(List<ProductEntity> productsEntity) {
List<ProductBean> productsBean = new ArrayList<ProductBean>();
if (productsEntity != null) {
for (ProductEntity product : productsEntity) {
productsBean.add(parserEntityToBean(product));
}
}
return productsBean;
}
public static List<CategoryBean> parseCategoryEntitiesToBeans(List<CategoryEntity> categoriesEntity) {
List<CategoryBean> categoriesBean = new ArrayList<CategoryBean>();
if (categoriesEntity != null) {
for (CategoryEntity category : categoriesEntity) {
categoriesBean.add(parserEntityToBean(category));
}
}
return categoriesBean;
}
}
Os testes dos serviços são realizados utilizando JUnits. Em nosso exemplo são apenas dois testes, um de busca e outro de inserção. Fiquem a vontade para fazer um teste unitário para cada serviço. A seguir é mostrado o código responsável por estes testes.
package br.com.branquinho.hibernate.database.test;
import java.util.List;
import org.apache.log4j.Logger;
import org.junit.BeforeClass;
import org.junit.Test;
import br.com.branquinho.hibernate.database.ServicesFactory;
import br.com.branquinho.hibernate.database.interfaces.IDaoFactory;
import br.com.branquinho.hibernate.database.utils.DaoFactory;
import br.com.branquinho.hibernate.utils.database.beans.CategoryBean;
import br.com.branquinho.hibernate.utils.database.beans.ProductBean;
import br.com.branquinho.hibernate.utils.database.interfaces.IServicesFactory;
public class ServicesDatabaseTest {
private static final Logger logger = Logger.getLogger(ServicesDatabaseTest.class);
private static final IDaoFactory daoFactory = new DaoFactory();
private static final IServicesFactory serviceFactory = new ServicesFactory(daoFactory);
@BeforeClass
public static void beforeClass() {
logger.info("Instantiate DAO Factory and Service Factory.");
}
@Test
public void testFindAll() {
logger.info("Find all registers.");
// Find all categories.
List<CategoryBean> categories = serviceFactory.getCategoryService().findAllCategories();
for (CategoryBean category : categories) {
logger.info(String.format("Category [%s]", category));
}
// Find all products.
List<ProductBean> products = serviceFactory.getProductServices().findAllProducts();
for (ProductBean product : products) {
logger.info(String.format("Product [%s]", product));
}
}
@Test
public void testInsert() {
logger.info("Testing insertion.");
// Test insert a category.
String tmpCategory = "Category 05";
CategoryBean category = new CategoryBean();
category.setDescription(String.format("Description of the %s.", tmpCategory));
category.setName(String.format("Name %s.", tmpCategory));
Long idCategory = serviceFactory.getCategoryService().insert(category);
// Test insert a product.
String tmpProduct = "Product 05";
ProductBean product = new ProductBean();
product.setDescription(String.format("Description of the %s.", tmpProduct));
product.setName(String.format("Name %s.", tmpProduct));
product.setPrice(12.02d);
product.setCategory(new CategoryBean(idCategory));
serviceFactory.getProductServices().insert(product);
}
}
O próximo vídeo mostra a implementação destas classes.
Com isso finalizamos o módulo responsável por gerenciar o banco de dados e disponibilizar serviços.
No próximo post continuo o trabalho mostrando a integração do hibernate-application e hibernate-database.
Até o próximo post pessoal.
Olá a todos.
Neste post irei tratar dos serviços que são disponibilizados para o projeto hibernate-application. Estes serviços podem ser usados por qualquer outro módulo que venhamos a criar no futuro. Ele elimina a complexidade de acesso ao banco de dados.
Existem dois serviços, o ProductService e CategoryService. Para criar estes serviços existe a classe de ServicesFactory. Utilizando o padrão Factory esta classe é responsável por instanciar ProductService e CategoryService. Os serviços são retornados utilizando as interfaces IProductService e ICategoryService. Isso diminui o acoplamento entre os módulos e as classes.
A seguir, as interfaces IProductService e ICategoryService mostram os serviços que são disponibilizados.
package br.com.branquinho.hibernate.utils.database.interfaces;
import java.util.List;
import br.com.branquinho.hibernate.utils.database.beans.CategoryBean;
public interface ICategoryServices {
CategoryBean findById(Long id);
List<CategoryBean> findAllCategories();
Long insert(CategoryBean category);
void update(CategoryBean category);
void delete(CategoryBean category);
}
package br.com.branquinho.hibernate.utils.database.interfaces;
import java.util.List;
import br.com.branquinho.hibernate.utils.database.beans.ProductBean;
public interface IProductServices {
ProductBean findById(Long id);
List<ProductBean> findAllProducts();
Long insert(ProductBean product);
void update(ProductBean product);
void delete(ProductBean product);
}
A implementação destes serviços são as classes concretas CategoryService e ProductService. Os serviços utilizam os DAOs para fazer realizar as ações com o banco. Eles retornam beans, e não entidades. Para isso, temos a classe ParserDatabase. No próximo post mostro a implementação do ParserDatabase. Esta classe é muito simples e tem a única função de converter Entidades em Beans.
Os serviços CategoryService e ProductService são apresentados a seguir.
package br.com.branquinho.hibernate.database.services;
import java.util.List;
import br.com.branquinho.hibernate.database.interfaces.ICategoryDao;
import br.com.branquinho.hibernate.database.interfaces.IDaoFactory;
import br.com.branquinho.hibernate.database.utils.ParserDatabase;
import br.com.branquinho.hibernate.utils.database.beans.CategoryBean;
import br.com.branquinho.hibernate.utils.database.interfaces.ICategoryServices;
public class CategoryServices implements ICategoryServices {
private final ICategoryDao categoryDao;
// ///////////////////////////////////////////////////////////////////////////////
// CONSTRUCTORS
// ///////////////////////////////////////////////////////////////////////////////
public CategoryServices(IDaoFactory daoFactory) {
this.categoryDao = daoFactory.getCategoryDao();
}
// ///////////////////////////////////////////////////////////////////////////////
// PUBLIC METHODS (ICategoryServices)
// ///////////////////////////////////////////////////////////////////////////////
@Override
public CategoryBean findById(Long id) {
return ParserDatabase.parserEntityToBean(this.categoryDao.findById(id));
}
@Override
public List<CategoryBean> findAllCategories() {
return ParserDatabase.parseCategoryEntitiesToBeans(this.categoryDao.findAll());
}
@Override
public Long insert(CategoryBean category) {
return this.categoryDao.save(ParserDatabase.parserBeanToEntity(category));
}
@Override
public void update(CategoryBean category) {
this.categoryDao.update(ParserDatabase.parserBeanToEntity(category));
}
@Override
public void delete(CategoryBean category) {
this.categoryDao.delete(ParserDatabase.parserBeanToEntity(category));
}
}
package br.com.branquinho.hibernate.database.services;
import java.util.List;
import br.com.branquinho.hibernate.database.interfaces.IDaoFactory;
import br.com.branquinho.hibernate.database.interfaces.IProductDao;
import br.com.branquinho.hibernate.database.utils.ParserDatabase;
import br.com.branquinho.hibernate.utils.database.beans.ProductBean;
import br.com.branquinho.hibernate.utils.database.interfaces.IProductServices;
public class ProductServices implements IProductServices {
private final IProductDao productDao;
// ///////////////////////////////////////////////////////////////////////////////
// CONSTRUCTORS
// ///////////////////////////////////////////////////////////////////////////////
public ProductServices(IDaoFactory daoFactory) {
this.productDao = daoFactory.getProductDao();
}
// ///////////////////////////////////////////////////////////////////////////////
// PUBLIC METHODS (IProductServices)
// ///////////////////////////////////////////////////////////////////////////////
@Override
public ProductBean findById(Long id) {
return ParserDatabase.parserEntityToBean(this.productDao.findById(id));
}
@Override
public List<ProductBean> findAllProducts() {
return ParserDatabase.parseProductEntitiesToBeans(this.productDao.findAll());
}
@Override
public Long insert(ProductBean product) {
return this.productDao.save(ParserDatabase.parserBeanToEntity(product));
}
@Override
public void update(ProductBean product) {
this.productDao.update(ParserDatabase.parserBeanToEntity(product));
}
@Override
public void delete(ProductBean product) {
this.productDao.delete(ParserDatabase.parserBeanToEntity(product));
}
}
A ServiceFactory implementa a interface IServiceFactory. A responsabilidade desta classe é apenas de instanciar os serviços. As implementações são exibidas a seguir.
package br.com.branquinho.hibernate.utils.database.interfaces;
public interface IServicesFactory {
ICategoryServices getCategoryService();
IProductServices getProductServices();
}
package br.com.branquinho.hibernate.database;
import br.com.branquinho.hibernate.database.interfaces.IDaoFactory;
import br.com.branquinho.hibernate.database.services.CategoryServices;
import br.com.branquinho.hibernate.database.services.ProductServices;
import br.com.branquinho.hibernate.database.utils.DaoFactory;
import br.com.branquinho.hibernate.utils.database.interfaces.ICategoryServices;
import br.com.branquinho.hibernate.utils.database.interfaces.IProductServices;
import br.com.branquinho.hibernate.utils.database.interfaces.IServicesFactory;
/**
* Factory of services.
*
* @author augusto
*/
public class ServicesFactory implements IServicesFactory {
private final ICategoryServices categoryServices;
private final IProductServices productServices;
// ///////////////////////////////////////////////////////////////////////////////
// CONSTRUCTORS
// ///////////////////////////////////////////////////////////////////////////////
public ServicesFactory() {
IDaoFactory daoFactory = new DaoFactory();
this.categoryServices = new CategoryServices(daoFactory);
this.productServices = new ProductServices(daoFactory);
}
public ServicesFactory(IDaoFactory daoFactory) {
this.categoryServices = new CategoryServices(daoFactory);
this.productServices = new ProductServices(daoFactory);
}
// ///////////////////////////////////////////////////////////////////////////////
// PUBLIC METHODS (IServicesFactory)
// ///////////////////////////////////////////////////////////////////////////////
@Override
public ICategoryServices getCategoryService() {
return this.categoryServices;
}
@Override
public IProductServices getProductServices() {
return this.productServices;
}
}
Os vídeos a seguir demonstram estes serviços sendo criados.
Vídeo 10
Vídeo 11
No próximo post irei tratar dos testes dos serviços e da implementação dos parsers.
Até mais pessoal.