Pablo Gonzalez: 2012

sábado, 17 de novembro de 2012

Arquivo ClienteDaoImpl

Nome do arquivo ClienteDaoImpl (ClienteDaoImpl.java)

package daos;
import br.com.cliente.models.Cliente;
import br.com.cliente.utility.DaoGenericoImpl;
import br.com.cliente.utility.HibernateUtility;
import java.util.ArrayList;
import java.util.List;
import org.hibernate.Criteria;
public class ClienteDaoImpl extends DaoGenericoImpl < Cliente , Long > implements ClienteDao {
@Override
public List consultar() {
List lista = new ArrayList();
Criteria crit = HibernateUtility.getSession().createCriteria(Cliente.class);
lista = (List) crit.list();
return lista;
}
}

Arquivo ClienteDao

Nome do arquivo ClienteDao (ClienteDao.java)

package daos;
import br.com.cliente.models.Cliente;
import br.com.cliente.utility.DaoGenerico;
import java.util.List;
public interface ClienteDao extends DaoGenerico <Cliente, Long> {
public List consultar();
}

Arquivo HibernateUtility

Nome do arquivo HibernateUtility (HibernateUtility.java)

package br.com.cliente.utility;
import br.com.cliente.models.Cliente;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
public class HibernateUtility {
private static final SessionFactory factory;
private static final ThreadLocal sessionThread = new ThreadLocal();
private static final ThreadLocal transactionThread = new ThreadLocal();
public static Session getSession() {
Session session = (Session) sessionThread.get();
if ((session == null) || (!(session.isOpen()))) {
session = factory.openSession();
sessionThread.set(session);
}
return ((Session) sessionThread.get());
}
public static void closeSession() {
Session session = (Session) sessionThread.get();
if ((session != null) && (session.isOpen())) {
sessionThread.set(null);
session.close();
}
}
public static void beginTransaction() {
Transaction transaction = getSession().beginTransaction();
transactionThread.set(transaction);
}
public static void commitTransaction() {
Transaction transaction = (Transaction) transactionThread.get();
if ((transaction != null) && (!(transaction.wasCommitted())) && (!(transaction.wasRolledBack()))) {
transaction.commit();
transactionThread.set(null);
}
}
public static void rollbackTransaction() {
Transaction transaction = (Transaction) transactionThread.get();
if ((transaction != null) && (!(transaction.wasCommitted())) && (!(transaction.wasRolledBack()))) {
transaction.rollback();
transactionThread.set(null);
}
}
static {
try {
factory = new Configuration()
// /***MYSQL***/

.setProperty("hibernate.dialect", "org.hibernate.dialect.MySQLInnoDBDialect") // tipo de dialeto do banco
.setProperty("hibernate.connection.driver_class", "com.mysql.jdbc.Driver") // driver do banco
.setProperty("hibernate.connection.url", "jdbc:mysql://localhost:3306/cliente") // endereço do banco de dados
.setProperty("hibernate.connection.username", "root")

.setProperty("hibernate.connection.password", "08515453")

.setProperty("hibernate.hbm2ddl.auto", "update")

.setProperty("hibernate.c3p0.max_size", "10")

.setProperty("hibernate.c3p0.min_size", "2")

.setProperty("hibernate.c3p0.timeout", "5000")

.setProperty("hibernate.c3p0.max_statements", "10")

.setProperty("hibernate.c3p0.idle_test_period", "3000")

.setProperty("hibernate.c3p0.acquire_increment", "2")

.setProperty("show_sql", "true")

.setProperty("use_outer_join", "true")

.setProperty("hibernate.generate_statistics", "true")

.setProperty("hibernate.use_sql_comments", "true")

.setProperty("hibernate.format_sql", "true")

//CADASTROS abaixo coloque todas classes que deseja ser modelo para criação do banco de dados

.addAnnotatedClass(Cliente.class)

//MOVIMENTOS

.buildSessionFactory();

} catch (RuntimeException e) {
e.printStackTrace();
throw e;
}
}
public static void main(String [] args) {
}
}

Arquivo DaoGenericoImpl

Nome do arquivo DaoGenericoImpl( DaoGenericoImpl.java)

package br.com.cliente.utility;

import java.io.Serializable;

import java.lang.reflect.ParameterizedType;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

import org.hibernate.Criteria;

import org.hibernate.HibernateException;

import org.hibernate.LockOptions;

import org.hibernate.criterion.Restrictions;
public class DaoGenericoImpl<T, ID extends Serializable> implements DaoGenerico<T, ID> {
private final Class<T> oClass;
public DaoGenericoImpl() {
this.oClass = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];

}
@Override
public Class<T> getObjectClass() {
return this.oClass;
}
@Override
public T save(T objeto) {
try {
Object obj = null;
HibernateUtility.beginTransaction();
obj = HibernateUtility.getSession().merge(objeto);
HibernateUtility.commitTransaction();
HibernateUtility.closeSession();
return (T) obj;
} catch (HibernateException hibernateException) {
cancel();
throw hibernateException;
}
}
@Override
public void delete(T objeto) {
try {
HibernateUtility.beginTransaction();
HibernateUtility.getSession().delete(objeto);
HibernateUtility.commitTransaction();
HibernateUtility.closeSession();
} catch (HibernateException hibernateException) {
cancel();
throw hibernateException;
}
}
@Override
public void deleteItem(T objeto) {
try {
HibernateUtility.beginTransaction();
HibernateUtility.getSession().delete(objeto);
} catch (HibernateException hibernateException) {
cancel();
throw hibernateException;
}
}
@Override
public List<T> list() {
try {
List list = HibernateUtility.getSession().createCriteria(oClass).list();
//HibernateUtility.closeSession();
return (List<T>) list;
} catch (HibernateException hibernateException) {
cancel();
throw hibernateException;
}
}
@Override
public T getById(Serializable id) {
try {
return (T) HibernateUtility.getSession().get(oClass, id);
} catch (HibernateException hibernateException) {
cancel();
throw hibernateException;
}

}
@Override

public T getById(Serializable id, boolean lock) {
try {
if (lock) {
return (T) HibernateUtility.getSession().get(oClass, id, LockOptions.UPGRADE);
} else {
return (T) HibernateUtility.getSession().get(oClass, id);
}
} catch (HibernateException hibernateException) {
cancel();
throw hibernateException;
}
}
@Override
public List<T> listCriterio(String subClazz, Map<String, Object> filtrosConsulta, int tipoConsulta) {
List<T> lista = new ArrayList<T>();
Set entradas = filtrosConsulta.entrySet();
try {
Criteria crit = HibernateUtility.getSession().createCriteria(oClass);
if (subClazz == null) {
for (Iterator it = entradas.iterator(); it.hasNext();) {
Entry object = (Entry) it.next();
if (object.getValue() instanceof Enum) {
crit.add(Restrictions.eq(object.getKey().toString(), object.getValue()));
} else if (tipoConsulta == 0) {
crit.add(Restrictions.ilike(object.getKey().toString(), "%" + object.getValue() + "%"));
} else if (tipoConsulta == 1) {
crit.add(Restrictions.eq(object.getKey().toString(), object.getValue()));
} else if (tipoConsulta == 2) {
crit.add(Restrictions.gt(object.getKey().toString(), object.getValue()));
} else if (tipoConsulta == 3) {
crit.add(Restrictions.ge(object.getKey().toString(), object.getValue()));
} else if (tipoConsulta == 4) {
crit.add(Restrictions.lt(object.getKey().toString(), object.getValue()));
} else if (tipoConsulta == 5) {
crit.add(Restrictions.le(object.getKey().toString(), object.getValue()));
} else if (tipoConsulta == 2) {
crit.add(Restrictions.ne(object.getKey().toString(), object.getValue()));
}
}
} else {
for (Iterator it = entradas.iterator(); it.hasNext();) {
Entry object = (Entry) it.next();
//crit.createCriteria(subClazz).add(Restrictions.ilike(object.getKey().toString(), "%" + object.getValue() + "%"));
if (object.getValue() instanceof Enum) {
} else if (tipoConsulta == 0) {
crit.createCriteria(subClazz).add(Restrictions.ilike(object.getKey().toString(), "%" + object.getValue() + "%"));
} else if (tipoConsulta == 1) {
crit.createCriteria(subClazz).add(Restrictions.eq(object.getKey().toString(), object.getValue()));
} else if (tipoConsulta == 2) {
crit.createCriteria(subClazz).add(Restrictions.gt(object.getKey().toString(), object.getValue()));
} else if (tipoConsulta == 3) {
crit.createCriteria(subClazz).add(Restrictions.ge(object.getKey().toString(), object.getValue()));
} else if (tipoConsulta == 4) {
crit.createCriteria(subClazz).add(Restrictions.lt(object.getKey().toString(), object.getValue()));
} else if (tipoConsulta == 5) {
crit.createCriteria(subClazz).add(Restrictions.le(object.getKey().toString(), object.getValue()));
} else if (tipoConsulta == 2) {
crit.createCriteria(subClazz).add(Restrictions.ne(object.getKey().toString(), object.getValue()));

}

}
}
crit.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
crit.setMaxResults(20);
lista = (List<T>) crit.list();
//HibernateUtility.closeSession();
return lista;
} catch (HibernateException hibernateException) {
cancel();
throw hibernateException;
}
}
@Override
public List<T> consultaHQL(String consulta) {
return (List<T>) HibernateUtility.getSession().createQuery(consulta).list();
}
@Override
public void cancel() {
HibernateUtility.rollbackTransaction();
HibernateUtility.closeSession();
}
}

Arquivo DaoGenerico

Nome do arquivo DaoGenerico (DaoGenerico.java)

package br.com.cliente.utility;
import java.io.Serializable;
import java.util.List;
import java.util.Map;
public interface DaoGenerico<T, ID extends Serializable> {
public Class<T> getObjectClass();
public T save(T objeto);
public void delete(T objeto);
public void deleteItem(T objeto);
public List<T> list();
public List<T> listCriterio(String subClazz, Map<String, Object> filtrosConsulta, int tipoConsulta);
public T getById(Serializable id);
public T getById(Serializable id, boolean lock);
public List<T> consultaHQL(String consulta);
public void cancel();
}

Arquivo Cliente

Nome do Arquivo classe java (Cliente.java)

package br.com.cliente.models;
import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
@Entity
public class Cliente implements Serializable {
@Id
@GeneratedValue(strategy= GenerationType.IDENTITY)
private Long idCliente;
@Column(name="NOME", length=80)
private String Nome;
@Column(name="EMAIL", length=80)
private String email;
public Long getIdCliente() {
return idCliente;
}
public void setIdCliente(Long idCliente) {
this.idCliente = idCliente;
}
public String getNome() {
return Nome;
}
public void setNome(String Nome) {
this.Nome = Nome;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}

}

Arquivo ClienteBean

Arquivo classe Java (ClienteBean.java)

package br.com.cliente.controller;
import br.com.cliente.models.Cliente;
import daos.ClienteDao;
import daos.ClienteDaoImpl;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.SessionScoped;
import javax.faces.event.ActionEvent;
@ManagedBean
@SessionScoped
public class ClienteBean implements Serializable {
private Cliente cliente = new Cliente();
private List<Cliente> clientes = new ArrayList<Cliente>();
private ClienteDao dao = new ClienteDaoImpl();
public ClienteBean() {
clientes = dao.consultar(); // busca todos registros do banco e popula a lista de clientes
}
public void salvar(ActionEvent event) {
dao.save(cliente); // salvando no banco de dados
cliente = new Cliente(); // criando um novo objeto para caso for inserir novamente
clientes = dao.consultar();// busca os dados no banco após salvar para apresentar na tabela
}
public void editar() {
cliente = dao.getById(cliente.getIdCliente()); // busca no banco de dados qual registro que vai ser alterado.
}
public void excluir() {
dao.delete(cliente); // deleta do banco o cliente que está no objeto cliente, que foi setado na view.
clientes = dao.consultar();// busca os dados no banco após excluir para apresentar na tabela
}
public Cliente getCliente() {
return cliente;
}
public void setCliente(Cliente cliente) {
this.cliente = cliente;
}
public List<Cliente> getClientes() {
return clientes;
}
public void setClientes(List<Cliente> clientes) {
this.clientes = clientes;
}
}

Arquivo Cliente.xhtml

Nome do arquivo Cliente.xhtml

<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:f="http://java.sun.com/jsf/core"
xmlns:p="http://primefaces.prime.com.tr/ui"
xmlns:ui="http://java.sun.com/jsf/facelets">
<h:head>
<title>Cliente</title>
</h:head>
<h:body>
<h:form id="form">
<p:panel header="CLIENTE">
<p:messages />
<h:panelGrid columns="2">
<h:outputLabel value="NOME:" for="nome" />
<p:inputText id="nome" label="nome" value="#{clienteBean.cliente.nome}" maxlength="40" size="40" />

<h:outputLabel value="EMAIL:" for="email"/>
<p:inputText id="email" label="email" value="#{clienteBean.cliente.email}" maxlength="40" size="40"/>
<p:commandButton id="btnSalvar" value="SALVAR" actionListener="#{clienteBean.salvar}" update="form" />
</h:panelGrid>

<p:dataTable id="tabela" value="#{clienteBean.clientes}" var="cli" emptyMessage="Nenhum registro incluido." paginator="true" rows="10">

<f:facet name="header">
Lista de Clientes
</f:facet>

<p:column headerText="NOME" style="text-align: center">


<h:outputText value="#{cli.nome}" />

</p:column>

<p:column headerText="E-MAIL" style="text-align: center">
<h:outputText value="#{cli.email}" />
</p:column>

<p:column headerText="ALTERAR - EXCLUIR" style="text-align: center">

<p:commandButton action="#{clienteBean.editar}" value="EDITAR" title="Editar" ajax="false" >

<f:setPropertyActionListener value="#{cli}" target="#{clienteBean.cliente}" />
</p:commandButton>

<p:commandButton value="EXCLUIR" title="Excluir" onclick="confirmation.show()" style="margin-left: 5px" >

<f:setPropertyActionListener value="#{cli}" target="#{clienteBean.cliente}" />
</p:commandButton>
</p:column>
</p:dataTable>
</p:panel>
</h:form>

<h:form id="dlg">
<p:confirmDialog message="Deseja realmente excluir este registro?" hideEffect="explode" header="Aviso" severity="alert" widgetVar="confirmation" modal="true">

<p:commandButton id="btnSim" value="Sim" oncomplete="confirmation.hide();" actionListener="#{clienteBean.excluir}" process="@form" update="form:tabela" />

<p:commandButton id="btnNao" value="Não" onclick="confirmation.hide();" type="button"/>
</p:confirmDialog>
</h:form>
</h:body>
</html>

JSF com Modelo MVC

quinta-feira, 30 de agosto de 2012

MIS ou M.I.S – O que faz este profissonal?

O Primeiro contato – A experiência.

Há um tempo atrás eu era um “curioso” na área de TI, estudava tudo que encotrava relacionado a TI.
Depois de vários cursos e muito treino, consegui dominar uma linguagem: o Java.
Trabalhei como desenvolvedor de aplicações em Java para o Banco do Brasil e apartir dai adqueri experiêcia para seguir em frente.
Percebi que os conhecimentos adqueridos poderiam ser utilizados em outras áreas afins e desisti do curso de Analise de sistemas e comecei a fazer Gestão de Processos Gerencias.
Apartir dos conhecimentos da Gestão mudei meu foco do desenvolvimento de aplicações para cargos de Gestão.
Hoje vou falar um pouco sobre o cargo de MIS.

Definição Técnica

MIS ou M.I.S é a abreviação do termo em inglês de Management Information System, que traduzindo para o português chama-se SIG (Sistema de informação gerencial ou Sistema de informação de Gestão.

Modo de trabalho e pré-requisitos

O cargo de MIS e muito confundido no ambiente de trabalho com um analista de sistemas ou analista de de requisítos e até de desenvolvedor. Um analista de MIS não é um ‘Analista de Sistemas Apenas’, seu papel em uma corporação é extrair dados e relatórios de forma rápida que facilite na tomada de decisões. Para que um analista de M.I.S consiga extrair estas informações é fundamental que tenha conhecimento e acesso a sistemas de gerenciamento de banco de dados “SGDB”, consultas em SQL e imprescindivelmente elaboração de planilhas gerenciais e relatórios de fácil compreensão com foco na tomada de decisões.

“Dia a Dia e Rotinas Já vivênciadas”

Se você pretende trabalhar nesta área, saiba que o seu papel na empresa será fornecer informações importantes de modo fácil e rápido para o requisitante, geralmente o MIS trabalha diretamente ligado a diretoria ou a superintendência de uma empresa.

Como case use do papel do MIS na avaliação de capacitação operacional, que é um setor que treina as pessoas para suas rotinas operacionais. Dentro deste setor de capacitação operacional existem conjuntos de metas definidas para o instrutor de treinamento que são “Não Desistências“, é o modo com que este instrutor atua de forma a não perder pessoas por motivos que ele poderia ter evitado, Notas, que é o trabalho qualitativo dele e comparativo de como foi o desempenho que a pessoa que ele entregou na operação,neste ponto o analista de MIS faz o seu papel de apresentar de forma simplificada em relatorios para o superior imediato.

Conselhos pra quem vai atuar como Analista de MIS

Durante o período de experiência:

Não aceite demandas de desenvolvedor – Toda grande corporação ou empresa, na maioria das vezes tem demanda de pequeno sistemas que lhe permitam colhetar os dados, as pessoas que te pedem os relatórios, na maioria das vezes não tem o sistema ou base de dados que o geram, mas elas também sabem que você é um profissional de tecnologia, que conhece banco de dados e no mínimo estudou alguma coisa da área, por saberem disto as vezes confundem o seu papel e te pedem também pra desenvolver sistemas além do relatório. Muito cuidado quanto a isto, recuse a maioria das ofertas, negocie e transfira para o setor de desenvolvimento explicando suas razões, seja educado e contorne a situação, não se preoucupe com o prazo secular do setor de desenvolvimento, seu papel na empresa é fornecer informações gerencias. Só aceite em último caso, se aquela ferramenta for vital para o funcionamento da empresa e não existe outra hipótese, mas já sabendo das consequencias: Você com certeza vai ter que dar suporte a todo problema que existir na sua aplicação, e seu valioso tempo que consiste em executar a sua função vai ser gasto dando suporte aos sistemas criado por você, enquanto isso poderia estar aprimorando ou desenvolvendo seus relatórios, perdendo assim o ‘foco na carreira’.
Seja crítico, seja Humano – Um dos papeis fundamentais do analista de MIS é fornecer uma forma humana de intepretar a informação, pense como se fosse o gerente: “O que eu quero enxergar”? “Qual funcionário está sendo mais produtivo?” “Quais são meus principais gastos?” “Qual é a informação que eu preciso pra que me ajude a reduzir estes custos”? Baseando-se nestas perguntas você pode gerar informações e relatórios precisos, o que por consequência te eleva como profissional dentro da empresa.
Faça Integração dos relatórios – Coloque novos tópicos, Crie Conceitos. A questão é: não esperem que te peçam, pense em algo gerencial….. …. Então pensou? então vão te pedir, os gerentes não tem muito tempo para ficar te pedindo coisas, tenha as informações prontas, faça relações entre elas e atribua pontuações por exemplo: O instrutor Vagner teve 20% de desistência em sala, gastei 700 reais com passagem para que estas pessoas viessem ao treinamento ou com a contratação delas, mas os que ficaram no treinamento tiveram ótima produtividade na operação? Isto é bom? é ruim? atribua a pontuação, crie seus conceitos, após ficarem prontos, debata-os com seu superior, desta forma você ganha muito crédito e vão sempre lembrar de você e que seu relatório tem as informações que precisam. Mas tenha certeza que terá condições de fornecer informações rápidas e precisas, do contrário nem fale sobre o assunto, apenas tente desenvolver de modo discreto primeiro antes de apresentar o trabalho, procure ajuda mas não apresente uma idéia sem ter condições de fazê-la.

segunda-feira, 27 de agosto de 2012

Cidades Digitais: Governo garante levar serviços a 80 municípios até dezembro

O Ministério das Comunicações divulgou nesta segunda-feira, 2/7, a lista dos 80 municípios que farão parte do projeto piloto de implantação de cidades digitais. O governo federal vai aplicar diretamente R$ 40 milhões na construção de redes metropolitanas de fibras ópticas, a partir de empresas que serão selecionadas em pregão eletrônico.

“As cidades terão um anel de fibras ópticas que vai conectar todos os órgãos públicos das prefeituras e até o fim de julho a SLTI [secretaria de logística e TI do Ministério do Planejamento] lançará os editais relacionados aos aplicativos de gestão. Se não houver nenhum problema, tudo estará pronto até o fim de dezembro”, explica a secretária de inclusão digital do Minicom, Lygia Pupatto.

Os 80 municípios contemplados foram selecionados a partir de 192 propostas de projeto apresentadas ao ministério e levam em conta critérios de porte e desenvolvimento – são cidades de até 50 mil habitantes com baixo IDH. Além disso, todas encontram-se em raio de até 50 km do backbone da Telebras, para viabilizar as conexões.

Apesar da coincidência entre os calendários do projeto e dos pleitos municipais, Pupatto descarta influência nas eleições para prefeito deste ano. “São apenas 80 cidades, um número pequeno considerando-se o tamanho do Brasil, e o projeto só ficará pronto depois das eleições. Não terá impacto”, sustenta a secretária de inclusão digital.

A infraestrutura será custeada com recursos federais – diretamente, sem repasse aos municípios – mas são as prefeituras que ficarão responsáveis pela contratação da capacidade de acesso. Assim, embora a arquitetura facilite a oferta desse serviço pela Telebras, os prefeitos podem preferir contratar banda de operadoras privadas.

Em resumo, o governo federal vai financiar as redes de fibras, que serão doadas aos municípios. As prefeituras, então, poderão assumir diretamente o custeio ou autorizar a prestação do serviço por terceiros. Nesse caso, a capacidade extra – após de atendidos os pontos públicos – poderá ser vendida, o que permitiria a continuidade dos acessos e a manutenção da rede sem custos para as cidades.

O desenho inicial prevê uma garantia mínima de capacidade, equivalente a 4Mbps em cada um, até o máximo de 30, dos pontos públicos de acesso – órgãos públicos e “hotspot”, como uma “praça digital” ou, provavelmente, um telecentro. “A menor rede deverá ter quatro pontos de governo e um ponto público”, explica o diretor de infraestrutura para inclusão digital, Americo Bernardes.

Veja as cidades contempladas:

Centro-Oeste
Brasília/Estrutural

Nordeste
Guanambi-BA
Itaberaba-BA
Itabuna-BA
Juazeiro-BA
Lauro de Freitas-BA
Nilo Peçanha-BA
Piraí do Norte-BA
Uruçuca-BA
Vitória da Conquista-BA
Araripe-CE
Barreira-CE
Brejo Santo-CE
Jaguaruana-CE
Maracanaú-CE
Milhã-CE
Quixeramobim-CE
São Gonçalo do Amarante-CE
Varjota-CE
Viçosa do Ceará-CE
São José de Ribamar-MA
Cabaceiras-PB
Cachoeira dos Índios-PB
Esperança-PB
Itaporanga-PB
Lagoa Seca-PB
Nova Floresta-PB
Pocinhos-PB
Queimadas-PB
São João do Rio do Peixe-PB
Bodocó-PE
Casinhas-PE
Correntes-PE
Inhuma-PI
Regeneração-PI
São José do Divino-PI
São João do Sabugi-RN

Norte
Coari-AM
Manacapuru-AM
Manaquiri-AM
Serra do Navio-AP
Conceição do Araguaia-PA
Curuça-PA
Goianésia do Pará-PA
Itaituba-PA
Marituba-PA
Paragominas-PA
Trairão-PA
Tucuruí-PA
Uruará-PA

Sudeste
Cariacica-ES
Nepomuceno-MG
Pimenta-MG
Rio Acima-MG
Engenheiro Paulo de Frontim-RJ
Maricá-RJ
São José do Vale do Rio Preto-RJ
Casa Branca-SP
Descalvado-SP
Guararapes-SP
Lourdes-SP
Penápolis-SP
Presidente Epitácio-SP
Santa Gertrudes-SP
Socorro-SP

Sul
Assis Chateaubriand-PR
Bandeirantes-PR
Ibiporã-PR
Palmas-PR
Quatro Barras-PR
Santa Cecília do Pavão
São Miguel do Iguaçu-PR
Toledo-PR
Candelária-RS
Jari-RS
Não-Me-Toque-RS
Nova Bassano-RS
Santo Ângelo-RS
São Miguel das Missões-RS
Joaçaba-SC

sexta-feira, 10 de agosto de 2012

Test-Driven Development - TDD

Test-Driven Development (TDD) ( Beck 2003 ; Astels 2003 ), é uma abordagem evolutiva para o desenvolvimento que combina teste anterior de desenvolvimento onde você escreve um teste antes de escrever código de produção apenas o suficiente para executar o teste e refatoração . Qual é o principal objetivo do TDD? Um ponto de vista é o objetivo do TDD é a especificação e não validação ( Martin, Newkirk, e Kess 2003 ). Em outras palavras, é uma maneira de pensar através de suas necessidades ou de design antes de escrever seu código funcional (o que implica que TDD é tanto um importante requisitos ágeis e design ágil técnica). Outra opinião é que TDD é uma técnica de programação. Como Ron Jeffries gosta de dizer, o objetivo do TDD é escrever código limpo que funciona. Eu acho que há mérito em ambos os argumentos , embora eu prefira a visão da especificação, mas deixo para você decidir.

1. O que é TDD ?
As etapas de desenvolvimento de teste (TFD) é supervisionada no diagrama de atividade UML da Figura 1 . O primeiro passo é adicionar rapidamente um teste, o código basicamente o suficiente para falhar. Em seguida, você executa seus testes, muitas vezes, a suíte de testes e completa embora por causa da velocidade que você pode decidir executar apenas um subconjunto, para garantir que o novo teste é de fato falhar. Você, então, atualizar seu código funcional para fazê-lo passar nos novos testes. O quarto passo é executar os testes novamente. Se eles falharem você precisa atualizar seu código funcional e teste novamente. Uma vez que os testes de passar o próximo passo é começar de novo (talvez seja necessário para refatorar qualquer duplicidade de seu projeto, conforme necessário, transformando o TFD em TDD).

Figura 1. As etapas de teste-primeiro desenvolvimento (TFD)

Eu gostaria de descrever o TDD com esta fórmula simples:

TDD Refactoring = + TFD.

TDD muda completamente o desenvolvimento tradicional. Quando você vai implementar um novo recurso, a primeira questão que se pergunta é se o design existente é o melhor projeto possível que lhe permite implementar esta funcionalidade. Se assim for, proceder através de uma abordagem TFD. Se não, você refatorar localmente para mudar a parte do projeto afetada pela nova funcionalidade, permitindo-lhe adicionar esse recurso tão fácil quanto possível. Como resultado, você será sempre a melhoria da qualidade de seu projeto, tornando assim mais fácil trabalhar com, no futuro.

. Em vez de escrever código funcional primeiro e depois o código de teste como um adendo, se você escrevê-lo em tudo, você deve escrever o código de teste antes de seu código funcional Além disso, você fazê-lo em passos muito pequenos - um teste e um pequeno pedaço de código funcional correspondente ao mesmo tempo. Um programador de uma abordagem TDD se recusa a escrever uma nova função até que haja primeiro um teste que falhe porque esta função não está presente. Na verdade, eles se recusam a adicionar uma única linha de código até que uma teste existe para ele. Uma vez que o teste está no lugar que, em seguida, fazer o trabalho necessário para garantir que o conjunto de testes passa agora (o novo código pode quebrar alguns dos testes existentes, bem como a nova). Isso parece simples, em princípio, mas quando você está aprendendo a ter uma abordagem TDD prova exige muita disciplina, porque é fácil "escorregar" e escrever o código funcional sem escrever um novo teste. Uma das vantagens da programação em pares é que o seu par ajuda-o a permanecer na pista .

Existem dois níveis de TDD:

Aceitação TDD (ATDD) . Com ATDD você escreve um único teste de aceitação , ou especificação comportamental, dependendo da sua terminologia preferida, e, em seguida, apenas o suficiente funcionalidade de produção / código para executar o teste. O objetivo do ATDD é especificar detalhados, requisitos executáveis para sua solução em uma só base no tempo (JIT). ATDD também é chamado de Behavior Driven Development (BDD).

Desenvolvedor TDD . Com desenvolvedor TDD você escreve um teste único desenvolvedor, por vezes, erroneamente referido como um teste de unidade, e então código de produção apenas o suficiente para executar o teste. O objetivo do desenvolvedor TDD é especificar um projeto detalhado e executável para sua solução em uma base JIT. Desenvolvedor TDD é muitas vezes chamado simplesmente TDD.

A Figura 2 mostra um diagrama de atividade UML mostrando como ATDD e desenvolvedor TDD se encaixam. Idealmente, você vai escrever um teste de aceitação única, em seguida, para implementar o código de produção necessário para executar o teste você vai ter um desenvolvedor abordagem TDD. Este, por sua vez exige que você iterar várias vezes ao longo do ciclo escrever um teste, escreva o código de produção, fazê-lo funcionar no nível TDD desenvolvedor.

Figura 2. Como aceitação TDD TDD e desenvolvedor trabalham juntos.

Note que a Figura 2 pressupõe que você está fazendo ambos, embora seja possível fazer qualquer um sem o outro. De fato, algumas equipes farão desenvolvedor TDD sem fazer ATDD, ver os resultados da pesquisa abaixo , mas se você está fazendo ATDD então é praticamente certo que você está fazendo também desenvolvedor TDD. O desafio é que ambas as formas de TDD requer profissionais ter habilidades de ensaios técnicos, habilidades que os profissionais de exigência muitas vezes não têm (ainda outra razão pela qual especialistas generalizantes são preferíveis para os especialistas).
Um pressuposto subjacente de TDD é que você tem uma estrutura de teste disponível para você.   Para as pessoas de aceitação TDD usará ferramentas como Fitnesse ou RSpec e para desenvolvedor TDD alguns desenvolvedores de software Gile freqüentemente usam a família xUnit de ferramentas de código aberto, tais como JUnit ou VBUnit , embora as ferramentas comerciais também são opções viáveis.   Sem tais ferramentas TDD é praticamente impossível. Figura 3 apresenta um diagrama de estados UML de como as pessoas normalmente trabalham com essas ferramentas. Este diagrama me foi sugerido por Keith Ray.

Figura 3. Testando com o Framework xUnit.
Kent Beck, que popularizou o TDD em eXtreme Programming (XP) ( Beck, 2000 ), define duas regras simples para TDD ( Beck 2003 ).   Primeiro, você deve escrever código novo negócio apenas quando um teste automatizado falhou.   Em segundo lugar, você deve eliminar qualquer . duplicação que você encontra   Beck explica como essas duas regras simples gerar indivíduo complexo e comportamento de grupo:

Você desenvolve organicamente, com o código executando fornecimento de feedback entre as decisões.

Você escreve seus próprios testes porque você não pode esperar 20 vezes por dia para alguém para escrevê-los para você.

Seu ambiente de desenvolvimento deve oferecer uma resposta rápida a pequenas alterações (por exemplo, você precisa de um compilador rápido e um conjunto de testes de regressão).

Seus desenhos devem ser constituídos de componentes altamente coesivos, fracamente acoplados (por exemplo, seu design é altamente normalizado) para fazer o teste mais fácil (o que também torna a evolução e manutenção do seu sistema mais fácil também).

Para os desenvolvedores, a implicação é que eles precisam aprender a escrever testes de unidade eficazes.   experiência de Beck é que bons testes:

Corra rápido (eles têm configurações curtas, execução e finalização).

Executar de forma isolada (você deve ser capaz de reordená-las).

Use os dados que torna fácil de ler e de entender.

Use os dados reais (por exemplo, cópia de dados de produção) quando eles precisam.

Representam um passo em direção ao seu objetivo global.
2. teste TDD e Tradicional

TDD é basicamente uma técnica de especificação com um efeito colateral de garantir que seu código-fonte é testado em um nível de confirmação.   No entanto, há mais testes do que isso.   Particularmente em escala y ou'll ainda precisa considerar outros testes ágeis tais técnicas como pré-produção de testes de integração e testes de investigação .   Muito deste teste também pode ser feito no início de seu projeto se você optar por fazê-lo (e deverá).

Com os testes tradicionais um teste bem sucedido encontra um ou mais defeitos.   É o mesmo com TDD, quando um teste falhar, você têm feito progressos, porque agora sabe que você precisa para resolver o problema.   Mais importante, você tem uma medida clara de sucesso quando o teste não falha mais. TDD aumenta a sua confiança de que seu sistema realmente atende aos requisitos definidos para ele, que o sistema realmente funciona e, portanto, você pode prosseguir com confiança.

Tal como acontece com os testes tradicionais, o maior perfil de risco do sistema dos mais completos os testes precisam ser. Com ambos os testes tradicionais e TDD você não está buscando a perfeição, em vez você está testando a importância do sistema. Parafraseando Agile Modeling (AM) , você deve "testar com um propósito" e saber por que você está testando algo e em que nível ele precisa ser testado. Um efeito colateral interessante de TDD é que você consegue teste 100% de cobertura - cada linha de código é testado - algo que os testes tradicionais não garante (embora não recomendo). Em geral, eu acho que é bastante seguro dizer que, embora TDD é uma técnica de especificação, um efeito colateral importante é que ela resulta em um código significativamente melhor do que as técnicas tradicionais.
Se vale a pena construir, vale a pena testar.

Se não a pena testar, por que você está desperdiçando seu tempo a trabalhar nele?
3. TDD e Documentação
Goste ou não a maioria dos programadores não ler a documentação escrita para um sistema, em vez disso, preferem trabalhar com o código. E não há nada de errado com isso. Ao tentar compreender a maioria dos programadores de classe ou operação vai procurar primeiro pelo código de exemplo que já chama-lo. Testes de unidade bem escritos fazem exatamente isso - a fornecer uma especificação de trabalho de seu código funcional - e como uma unidade resultado testa se tornar efetivamente uma parcela significativa de sua documentação técnica. A implicação é que as expectativas da multidão pró-documentação precisa refletir essa realidade. Da mesma forma, os testes de aceitação pode formar uma parte importante da documentação de requisitos. Isso faz muito sentido quando você parar e pensar sobre isso. Seus testes de aceitação definir exatamente o que seus stakeholders esperam do sistema, portanto, especificar os requisitos críticos. Seu conjunto de testes de regressão, particularmente com uma abordagem de teste de primeira, torna-se efetivamente detalhadas especificações executáveis .

Os testes de documentação suficiente? Muito provavelmente não, mas eles formam uma parte importante dela. Por exemplo, é provável que você achar que você ainda precisa do usuário do sistema, visão geral, operações e documentação de suporte. Você pode até achar que você precisar de documentação resumida do processo de negócio que o sistema suporta. Quando você se aproxima de documentação com uma mente aberta, eu suspeito que você vai achar que estes dois tipos de testes de cobrir a maioria de sua documentação precisa para desenvolvedores e stakeholders. Além disso, são um exemplo maravilhoso de AM da prática de fonte única de informação e uma parte importante de seus esforços globais para ficar tão ágil como a documentação relativa possível .
4. Test-Driven Development banco de dados

No momento da redação deste texto uma questão importante a ser feita na comunidade ágil "pode TDD trabalhar para o desenvolvimento orientado a dados?" Quando você olha para o processo representado na Figura 1 , é importante notar que nenhuma das etapas especificar programação objeto linguagens, como Java ou C #, mesmo que esses são os ambientes de TDD é tipicamente usados dentro Por que você não poderia escrever um teste antes de fazer uma mudança de esquema do banco de dados? Por que você não poderia fazer a mudança, executar os testes e refatorar seu esquema como necessária? Parece-me que você só precisa escolher a trabalhar desta forma.

Meu palpite é que no curto prazo do banco de dados TDD, ou talvez Teste Database Design Driven (TDDD), não vai funcionar tão bem como aplicação TDD. O primeiro desafio é o suporte da ferramenta. Embora unidade de teste de ferramentas, tais como DBUnit , estão agora disponíveis ainda são uma tecnologia emergente no momento da redação deste texto. Alguns DBAs estão melhorando a qualidade dos testes que estão fazendo, mas eu ainda não vi ninguém fazer uma abordagem TDD para o desenvolvimento de banco de dados. Um desafio é que as ferramentas de testes de unidade ainda não são bem aceitos na comunidade de dados, embora isso esteja mudando, por isso a minha expectativa é que ao longo dos próximos anos, banco de dados TDD vai crescer. Em segundo lugar, o conceito de desenvolvimento evolutivo é novo para muitos profissionais de dados e como resultado a motivação para tomar uma abordagem TDD ainda tem que se firmar. Esse problema afeta a natureza das ferramentas disponíveis para profissionais de dados - porque uma mentalidade de série ainda domina dentro da comunidade tradicional a maioria das ferramentas não suportam desenvolvimento evolutivo. Minha esperança é que os fornecedores de ferramentas vai pegar para essa mudança de paradigma, mas a minha expectativa é de que vamos precisar para desenvolver ferramentas de código aberto. Em terceiro lugar, a minha experiência é que a maioria das pessoas que fazem trabalho orientado dados parecem preferir um modelo orientado, e não uma abordagem test-driven. Uma das causas disso é provável, porque uma abordagem test-driven não tem sido amplamente considerada até agora, outra razão pode ser que muitos profissionais são susceptíveis de dados visuais e por isso preferem uma abordagem orientada a modelos.

5. Escala TDD via Agile Model-Driven Development (AMDD )

TDD é muito bom em especificação detalhada e validação, mas não tão boa para pensar em questões maiores, tais como a concepção global, como as pessoas irão usar o sistema, ou o design da interface (por exemplo). Modelagem, ou mais até o ponto de desenvolvimento orientado por modelo ágil (AMDD) (o ciclo de vida para a qual é capturada em Figura 4 ) é mais adequado para isso. AMDD aborda as dimensionamento ágeis questões que TDD não faz.

Figura 4 . O Modelo de Desenvolvimento Ágil Dirigido ciclo de vida (AMDD).

6. Por TDD?
Uma vantagem significativa do TDD é que ele permite que você tomar pequenos passos ao escrever software.   Esta é uma prática que eu tenho promovido por anos porque é muito mais produtivo do que tentar codificar em passos largos.   Por exemplo, suponha que você adicionar alguma nova código funcional, compilar e testar.   chances são muito boas que os testes serão quebrados por defeitos que existem no novo código.   É muito mais fácil de encontrar, e então reparar, estes defeitos se você escreveu duas novas linhas de código de dois mil. A implicação é que quanto mais rápido o seu compilador e conjunto de teste, o mais atraente é continuar com passos cada vez menores.   Eu geralmente preferem adicionar algumas linhas novas de código funcional, tipicamente menos de 10, antes de recompilar e executar novamente o meu testes.

Eu acho que Bob Martin diz que "o ato de escrever um teste de unidade é mais um ato de desígnio e não de verificação.   É também mais um ato de documentação do que de verificação.   O ato de escrever um teste de unidade fecha um grande número de comentários loops, menos do que é o único pertencente a verificação da função ".

A primeira reação que muitas pessoas têm de técnicas ágeis é que elas funcionam bem para projetos pequenos, talvez envolvendo um punhado de pessoas durante vários meses, mas que não iria trabalhar para "reais" projetos que são muito maiores.    Isso simplesmente não é verdade. Beck (2003) relatórios de trabalho em um sistema de Smalltalk uma abordagem totalmente orientado a testes, que teve 4 anos e 40 anos pessoa de esforço, resultando em 250.000 linhas de código funcional e 250.000 linhas de código de teste. Existem testes de corrida em 4000 menos de 20 minutos, com o conjunto completo que está sendo executado várias vezes ao dia. Embora existam sistemas de grande porte lá fora, eu pessoalmente trabalhei em sistemas onde várias centenas de pessoas-ano de esforço foram envolvidos, é claro que TDD trabalha para bom tamanho sistemas.

7. Mitos e Equívocos
Existem vários mitos e concepções erradas comuns que as pessoas têm sobre TDD que eu gostaria de esclarecer se possível.

quarta-feira, 13 de junho de 2012

O padrão DAO - Data Access Object

Este padrão permite criar as classes de dados independentemente da fonte de dados ser um BD relacional, um arquivo texto, um arquivo XML, etc. Para isso, ele encapsula os mecanismos de acesso a dados e cria uma interface de cliente genérica para fazer o acesso aos dados permitindo que os mecanismos de acesso a dados sejam alterados independentemente do código que utiliza os dados.

package br.delphos.persistencia;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class DAO {

    Connection con;
    PreparedStatement pstm;
    ResultSet rs;

    public void abrirBanco() throws Exception{
        Class.forName("com.mysql.jdbc.Driver");
        String url = "jdbc:mysql://localhost:3306/sistema1";
        String use = "root";
        String password = "08515453";
        con = DriverManager.getConnection(url, use, password);
       }
   public void fecharBanco()throws Exception{
       if(con != null)
           con.close();
       if(pstm != null)
           pstm.close();
   }
}

--------------------------------------------------------------------------------------------------------

package br.delphos.persistencia;

import br.delphos.modelo.Pessoa;

public class PessoaDAO extends DAO {

public void deletar(int x)throws Exception{
     abrirBanco();
     String query = "delete from pessoa where id=?";
     pstm = con.prepareStatement(query);
     pstm.setInt(1, x);
     pstm.execute();

     fecharBanco();
}
public void gravar(Pessoa p)throws Exception{
       abrirBanco();
       pstm = con.prepareStatement("insert into pessoa values(null, ?, ?,?)");
       pstm.setString(1,p.getNome());
       pstm.setString(2,p.getEmail());
       pstm.setString(3, p.getSexo());
       pstm.execute();
       fecharBanco();
    }

public void update(Pessoa p)throws Exception{
    abrirBanco();
    String query = "update pessoa set nome=?, email=?, sexo = ? where id =? ";
    pstm = con.prepareStatement(query);
    pstm.setString(1, p.getNome());
    pstm.setString(2, p.getEmail());
    pstm.setString(3, p.getSexo());
    pstm.executeUpdate();
    fecharBanco();

    }


   public Pessoa buscarporId(int id)throws Exception{
       abrirBanco();
       Pessoa p = new Pessoa();

       String query = "select * from pessoa where id=?";
       pstm = con.prepareStatement(query);
       pstm.setInt(1, id);
       rs = pstm.executeQuery();
       if(rs.next()){
           p.setId(rs.getInt("id"));
           p.setNome(rs.getString("nome"));
           p.setEmail(rs.getString("email"));
           p.setSexo(rs.getString("sexo"));

       }

       fecharBanco();
        return p;
   }

}
------------------------------------------------------------------------------------------------------
Visão - View
"Renderiza" o model em uma forma específica para a interação, geralmente uma interface de usuário.

package br.delphos.visao;
import br.delphos.modelo.Pessoa;
import br.delphos.persistencia.PessoaDAO;
import java.util.Scanner;

public class Atualizar{

public static void main(String args[]){
Atualizar a = new Atualizar();
a.atualizar();
}
public void atualizar(){
    try{
        Scanner sc = new Scanner(System.in);
        PessoaDAO pd = new PessoaDAO();
        Pessoa p1 = new Pessoa();

        System.out.printf("Digite um id a ser atulizado: ");
        p1.setId(sc.nextInt());
        sc.nextLine();
        System.out.printf("Digite o nome a ser atualizado: ");
        p1.setNome(sc.nextLine());
        System.out.printf("Digite o e-mail para ser atualizado: ");
        p1.setEmail(sc.nextLine());
        System.out.printf("Digite o sexo a ser atulizado: ");
        p1.setSexo(sc.nextLine());
        pd.update(p1);
        System.out.printf("Atulizado com exito");
        }
         catch(Exception e){
         System.out.println("erro " + e.getMessage());
         }

}
}
------------------------------------------------------------------------------------------------------

package br.delphos.visao;

import br.delphos.modelo.Pessoa;
import br.delphos.persistencia.PessoaDAO;
import java.util.Scanner;

public class Consultar{

    public static void main(String arg[]){
    Consultar c = new Consultar();
    c.buscarID();

}
    public void buscarID(){
         Scanner input = new Scanner(System.in);
         PessoaDAO pd = new PessoaDAO();
     try{

         System.out.printf("Digite um id para buscar: ");
         Pessoa p = pd.buscarporId(input.nextInt());

         System.out.println("Id: "+p.getId());
         System.out.println("Nome: "+p.getNome());
         System.out.println("E-mail: "+ p.getEmail());
         System.out.println("Sexo: "+p.getSexo());

     }
     catch(Exception e){
     System.out.println("Error "+e.getMessage());
     }
    }

}
--------------------------------------------------------------------------------------------------
package br.delphos.visao;

import br.delphos.persistencia.PessoaDAO;
import java.util.Scanner;

public class Deletar {
public static void main(String arg[]){
Deletar m = new Deletar();
m.excluir();
}

public void excluir(){
     Scanner sc = new Scanner(System.in);
     PessoaDAO pd = new PessoaDAO();
     System.out.printf("Digite o numero do registro a ser excluido: ");
     try{
     pd.deletar(sc.nextInt());
     System.out.printf("Registro deletado com sucesso: ");
     }
     catch(Exception e ){
     System.out.println("Erro "+e.getMessage());
     }

}

}
-------------------------------------------------------------------------------------------------------

package br.delphos.visao;

import br.delphos.modelo.Pessoa;
import br.delphos.persistencia.PessoaDAO;
import java.util.Scanner;

public class Main {

    public static void main(String args[]){
        Main m = new Main();
        m.gravar();

    }
    public void gravar(){
    try{
    Scanner s = new Scanner(System.in);
    Pessoa p = new Pessoa();
    PessoaDAO pd = new PessoaDAO();
    System.out.printf("Digite o nome: ");
    p.setNome(s.nextLine());
    System.out.printf("Digite o e-mail: ");
    p.setEmail(s.nextLine());
    System.out.printf("Digite o sexo: ");
    p.setSexo(s.nextLine());
    pd.gravar(p);

    System.out.println("inclusão feita com sucesso");
    }
    catch(Exception e){
    System.out.println("Erro: " +e.getMessage());

    }

}
}

Este post tem o objetivo de expressar códigos java de forma livre obedecendo o padrão MVC

Vários códigos como estes vão ser postados para iniciantes.

este e o modelo criado no netbeans:

package br.delphos.modelo;
public class Pessoa {
    private String id;
    private String nome;
    private String sexo;
    private String email;
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getNome() {
        return nome;
    }
    public void setNome(String nome) {
        this.nome = nome;
    }
    public String getSexo() {
        return sexo;
    }
    public void setSexo(String sexo) {
        this.sexo = sexo;
    }
    public void setId(int nextInt) {
        this.id = id;
    }

Pablo Gonzalez