Java sem café.!

Feliz 2012 [OFF]

2011-12-30T18:59:00.003-03:00

Este ano foi fantástico.. muitas aulas, muito trabalho, muito aprendizado...Desejo a todos Novas Dúvidas... Novos Questionamentos.... Novas formas....Que Deus permita continuar com vcs, contribuindo, ajudando e aprendendo...Grande abraço a todos e até 2012

Tutorial PDFBox

2011-11-03T19:03:00.004-03:00

PDFBox é uma biblioteca que permite manipular arquivos PDF, seja para criação de novos documentos ou mesmo de documentos já existentes, permitindo a extração de seu

[OFF] Java sem café.! está com mais um autor :D

2011-10-22T20:08:00.000-03:00

Olá pessoal!Só estou escrevendo para informar que a partir de hoje, teremos mais postagens sobre diversos assuntos relacionados à Java. Isso porque o Java sem café.! (e eu principalmente) está tendo a honra de contar com as postagens de quem eu considero que foi meu mestre, que me ensinou tudo o que eu sei sobre Java EE, que foi alguém que eu tive a grande oportunidade de trabalhar em 2009/2010.

JSF 2.0: Componentes PrimeFaces 2.2.1 - Parte 6

2011-08-09T17:59:00.000-04:00

Olá Pessoal!Depois de mais de um mês aqui estou eu voltando com as postagens do Java sem café.! E para começar bem, nada melhor do que continuar com as postagens sobre o PrimeFaces! Lembrando, a ultima postagem sobre o PrimeFaces foi a Parte 5, nela eu comentei sobre não ter conseguido fazer os gráficos do PrimeFaces, pois bem, com a ajuda do amigo Jamir Luiz, agora eu consegui fazer os gráficos

[OFF] Aniversário de 1 ano do Blog!

2011-07-31T16:43:00.000-04:00

Olá pessoal! Nessa postagem não vou falar sobre Java e afins... Pra mim hoje é um dia especial, hoje completa 1 ano que o Java sem café.! está no ar, alguns podem até falar: mas precisava criar uma postagem por isso!? Mas a resposta é que pra mim precisava sim!Vamos lá...Quando fui chamada para dar aulas na faculdade, precisava de um lugar para postar essas aulas, pois demora um pouco para novos

[OFF] Artigo: O uso da informática no processo de ensino-aprendizagem

2011-07-23T21:22:00.000-04:00

Oies!Para quem percebeu que eu andava ausente ultimamente do Java sem café.!, tenho uma explicação, estava em época final de uma especialização, dedicando assim tempo exclusivo para o artigo que passaria pela banca... porém enfim foi finalizado, e o melhor de tudo aprovado pela banca! Dessa forma para quem acompanhou ou para quem se interessar, estarei disponibilizando o artigo, segue o resumo

XStream: Criando e lendo arquivos XML

2011-06-10T14:14:00.019-04:00

Caso ainda não tenha precisado criar ou ler arquivos XML em Java, pelo menos já parou pra pensar como fazer isso? Criar uma String gigante concatenando valores e tags? Hoje em dia não há necessidade de se utilizar métodos tão "complexos" assim. Existe uma biblioteca chamada de XStream, onde objetos podem ser transformados em XML, e vice versa. Obs: o XStream gera uma String em formato de XML, e

JSF 2.0: Componentes PrimeFaces 2.2.1 - Parte 5

2011-06-07T19:32:00.000-04:00

Depois de vermos sobre menus do PrimeFaces, nessa postagem vamos ver alguns outros componentes. Vamos precisar de algumas umas imagens e algumas bibliotecas extras, baixe por aqui. Estrutura do projetoCaso não saiba como montar a estrutura do projeto veja aqui.Depois de pronto o projeto fica com essa estrutura: O primeiro componente que veremos hoje é o dataExporter que serve para exportar os

JasperReports 4.0.1: Utilizando Subreports e parâmetros

2011-06-04T22:16:00.000-04:00

Para esta não ser uma postagem muito extensa, irei utilizar o mesmo projeto e o mesmo relatório criado na postagem: agrupando de dados com JasperReports. Para completar esse projeto, logo abaixo do agrupamento eu vou listar os dados dos cliente, ou seja, terei um relatório de clientes embutido no relatório de pedidos (claro que pode ser feito outras coisas, este é apenas um exemplo) Começando...

JasperReports 4.0.1: Agrupando dados

2011-06-04T12:00:00.000-04:00

Na postagem de hoje vamos agrupar os pedidos por cliente, assim: Para este exemplo eu vou utilizar o JPA (visto em postagens anteriores), em um projeto Desktop, só para ser mais rápido, o foco da postagem será o agrupamento então para outros detalhes colocarei apenas os links com exemplos. Banco de dadosAntes de começar vamos ver qual será as tabelas utilizadas no banco de dados: Criando o

JSF 2.0: Componentes PrimeFaces 2.2.1 - Parte 4

2011-06-01T19:32:00.000-04:00

Continuando com a série de postagens de componentes PrimeFaces 2.2.1, hoje vamos ver a utilização de layout e menus! Teremos menus para todas as necessidades ;)Lembrando, que na postagem anterior vimos alguns componentes do tipo dialog, confirmDialog, entre outros: clique aqui para acessar.Para esse projeto, vamos precisar de alguns ícones... estou disponibilizando-os aqui, mas se quiser use seus

JasperReports 4.0.1: Criando gráficos no iReport com JDBC datasource - Gráfico tipo: pizza

2011-05-27T02:41:00.001-04:00

Depois de criarmos gráficos do tipo em barras, agora vamos criar gráficos do tipo pizza, para esta postagem eu vou usar JDBC datasouce, por ser mais prático, isso só para mostrar mesmo como criar gráficos usando o iReport.Obs: qualquer semelhança inicialmente com a postagem sobre gráficos em barras é mera coincidência... brincadeira, é puro CTRL C + CTRL V hahaha Banco de dadosTendo as seguintes

JasperReports 4.0.1: Criando gráficos no iReport com JDBC datasource - Gráfico tipo: barras

2011-05-27T00:49:00.002-04:00

Na postagem de hoje vamos gerar gráficos com JasperReports, para esta postagem eu vou usar JDBC datasouce, por ser mais prático, isso só para mostrar mesmo como criar gráficos usando o iReport. Banco de dadosTendo as seguintes tabelas no banco de dados: Se eu executar a seguinte query no banco:select cliente.nome, sum(pedido.valor) as total from cliente, pedido where pedido.cliente_codigo =

JasperReports 4.0.1: JDBC datasource - abrir relatório em projeto desktop

2011-05-25T03:30:00.004-04:00

Depois de vermos como chamar um relatório feito no JasperReports utilizando JDBC datasource em um projeto Web, nessa postagem vamos usar o mesmo relatório mas em um projeto Java Desktop!Reveja algumas postagens:JasperReports 4.0.1: Utilizando JDBC datasourceJasperReports 4.0.1: JDBC datasource - abrir relatório em projeto web Começando...Para começar, no NetBeans crie um novo Aplicativo Java com

JasperReports 4.0.1: JDBC datasource - abrir relatório em projeto web

2011-05-25T02:52:00.000-04:00

Dando continuidade na postagem: JasperReports 4.0.1: Utilizando JDBC datasource, agora vamos usar o .jasper gerado no iReport, em um projeto Java EE 6. Começando...Para começar, no NetBeans crie uma nova Aplicação Web com o nome de RelatorioJDBC (seguindo os passos já vistos em postagens anteriores), o estrutura final é este aqui: Feito isso, vamos começar a estruturar nosso projeto para usarmos

JSF 2.0: Componentes PrimeFaces 2.2.1 - Parte 3

2011-05-23T02:16:00.000-04:00

Vamos dar continuidade nas postagens sobre os componentes do PrimeFaces na versão 2.2.1. Na postagem anterior tratamos mais a parte de painéis, hoje será tratado de componentes um pouco mais úteis do que aqueles. Estrutura do projetoCaso não saiba como montar a estrutura do projeto veja aqui.Depois de pronto o projeto fica com essa estrutura:Antes de começar vamos ver o código fonte do nosso bean

JasperReports 4.0.1: Utilizando JDBC datasource

2011-05-22T19:34:00.002-04:00

Para quem está perdido no assunto, aconselho que vejam o início de tudo, nesse link também tem as ferramentas que vamos utilizar: iReport 4.0.1 e a biblioteca JasperReports 4.0.1 ... JasperReports 4.0.1: Conhecendo o iReport 4.0.1 Pra quem já está por dentro das postagens: depois de vermos como utilizar JavaBeans datasource em relatórios do JasperReports, vamos para uma parte mais simples, usar

JasperReports 4.0.1: JavaBean datasource - abrir relatório em projeto desktop

2011-05-22T16:44:00.002-04:00

Depois de vermos como chamar um relatório feito no JasperReports utilizando JavaBean, nessa postagem vamos usar o mesmo relatório mas em um projeto Java Desktop!Reveja algumas postagens:JasperReports 4.0.1: Utilizando JavaBean datasourceJasperReports 4.0.1: JavaBean datasource - abrir relatório em projeto web Começando...Caso tenha seguido a postagem Utilizando JavaBean datasource(link acima)

JSF 2.0: Componentes PrimeFaces 2.2.1 - Parte 2

2011-05-15T21:45:00.002-04:00

Bom lá vamos para a segunda postagem sobre componentes PrimeFaces 2.2.1, caso não tenha visto a primeira parte: veja aqui, nessa postagem eu vou tratar mais a parte de painéis. Estrutura do projetoCaso não saiba como montar a estrutura do projeto veja aqui.Depois de pronto o projeto fica com essa estrutura: Quando chegar a hora eu explico de onde pegar os .jpg que estão dentro de Páginas Web.

JasperReports 4.0.1: JavaBean datasource - abrir relatório em projeto web

2011-05-12T23:18:00.001-04:00

Dando continuidade na postagem: JasperReports 4.0.1: Utilizando JavaBean datasource, agora vamos usar o .jasper gerado no iReport, em um projeto Java EE 6. Começando...Para começar, no NetBeans crie uma nova Aplicação Web com o nome de PrimeiroRelatorio (seguindo os passos já vistos em postagens anteriores)...Feito isso, vamos criar a estrutura que usamos para gerar o .jasper (postagem do link),

JasperReports 4.0.1: Utilizando JavaBean datasource

2011-05-11T21:37:00.001-04:00

Observação: essa postagem tem por finalidade mostrar como construir relatórios utilizando de classes Java. O método utilizado é o JavaBean datasource, o que será feito aqui funciona tanto em Java desktop ou Java EE. Antes de começarmos, vamos entender algumas coisas: para usar esse método de criar relatórios nós precisamos de um .jar que contenha as classes que desejamos usar no relatório. Vale

JSF 2.0: Componentes PrimeFaces 2.2.1 - Parte 1

2011-05-08T22:04:00.004-04:00

Nessa postagem vamos começar com alguns componentes mais simples do PrimeFaces, caso não saiba por onde começar, recomendo ver essa postagem antes. Estrutura do projetoPara começar precisamos de um projeto web que já contenha o .jar do PrimeFaces (ver o link acima). Depois disso, dentro de pacotes de código-fonte crie um pacote com o nome de controle e dentro dele uma classe com o nome de

JSF 2.0: Utilizando o PrimeFaces 2.2.1 e seus temas

2011-05-08T19:41:00.003-04:00

Enfim vamos começar com as postagens sobre o PrimeFaces, que atualmente se encontra na versão 3.0M1 (veja os componentes aqui)... mas como essa versão foi lançada a pouco tempo, prefiro aguardar pela versão final para usá-la, vamos usar a versão anterior: 2.2.1 (componentes aqui), inicialmente teremos sete postagens mostrando alguns componentes (vários componentes em uma postagem).Para esta

JasperReports 4.0.1: Conhecendo o iReport 4.0.1

2011-05-06T12:20:00.031-04:00

O JasperReports é uma poderosa biblioteca para criação de relatórios, e o iReport é uma poderosa ferramenta para a utlização do Jasper. É importante saber que que os dois devem ser utilizados na mesma versão, o que isso quer dizer? se um relatório é compilado pelo iReport 4.0.1, na hora de utilizá-lo em um projeto, este deve conter as bibliotecas do JasperReports 4.0.1, caso contrário pode haver

Java EE 6: Segurança com Spring Security 3.0.5

2011-04-20T15:03:00.000-04:00

Quando se fala em sistemas online, logo deve-se pensar em como tratar a parte da segurança dos dados, de acesso... nessa postagens vamos trabalhar com a segurança de acesso ao sistema, ou seja, o login.Para fazer esse controle de login vou utilizar o framework Spring Security na versão 3.0.5, estarei disponibilizando os jar's usados, pois não aconselho baixar do próprio site deles, andei fazendo

JPA 2.0: Utilizando os NamedQuery

2011-04-17T18:50:00.004-04:00

Segundo a especificação do JEE 6, NamedQuery é definida como: "Specifies a static, named query in the Java Persistence query language. Query names are scoped to the persistence unit. The NamedQuery annotation can be applied to an entity or mapped superclass."Traduzindo... NamedQuery's são consultas Java Persistence estáticas e pré-definidas. Como são elas? Vamos usar como exemplo a postagem de

JSF 2.0: Ajax nativo

2011-03-30T00:47:00.025-04:00

Nessa postagem iremos fazer alguns exemplos de utilização da tag que é opção nativa para utlizar o ajax na versão 2.0 do JSF.Bom, vou postando os códigos fonte de cada exemplo e explicando o que cada um faz, ao final posto o bean que utilizei para os testes. Obs: todos os códigos dos componentes devem estar dentro de um h:form... Primeiro componente:Inicialmente eu vou criar um

JPA 2.0: Gerar classes a partir do banco com o Netbeans

2011-03-27T17:36:00.001-04:00

Assim como o JPA pode gerar o banco de dados, é possível a partir do banco de dados gerar as classes já com as anotações do JPA!Nesse exemplo vamos usar o Netbeans 6.9.1, não sei dizer se as outras versões do Netbeans funcionam da mesma forma. Tendo o seguinte banco, vamos gerar as classes automaticamente para ele: Crie um novo aplicativo web no Netbeans, com o nome de GerarClasses, em pacotes de

JSF 2.0: Componentes básicos

2011-03-27T11:18:00.066-04:00

O nome da postagem se refere ao JSF 2.0, mas os componentes que serão mostrados também funcionam no JSF 1.2. Para começar crie um projeto com o nome de ComponentesBasicos, dentro de pacotes de código-fonte crie um pacote com o nome de controle. Nossa base será um TesteBean.java que deverá ser criando dentro do pacote controle. Segue o código: @Named @javax.enterprise.context.RequestScoped public

JPA 2.0: Criando tabelas - Parte 3

2011-03-27T11:10:00.002-04:00

Dando sequência as postagens sobre JPA 2.0, nessa vamos entender como funciona a anotação @ManyToMany. Esta anotação serve para gerar uma tabela que resolva um relacionamento N - N entre duas classes. No caso de usar o @ManyToMany, você não vai precisar criar uma classe intermediária que será anotada, pelo contrário, você deverá apenas duas classes, por exemplo, uma Venda.java e uma Produto.java

JPA 2.0: CRUD com EJB 3.1

2011-03-17T18:25:00.046-04:00

Segundo a Oracle: "Enterprise JavaBeans (EJB) technology is the server-side component architecture for Java Platform, Enterprise Edition (Java EE). EJB technology enables rapid and simplified development of distributed, transactional, secure and portable applications based on Java technology."Nessa postagem vamos criar um CRUD utilizando EJB como forma de injetar a conexão com o banco de dados.

JSF 2.0: Utilização de Facelets

2011-03-17T00:41:00.015-04:00

O que é o Facelets? Segundo a especificação do Java EE 6: "Facelets is a powerful but lightweight page declaration language that is used to build JavaServer Faces views using HTML style templates and to build component trees." Java EE 6 Traduzindo... Facelets é uma poderosa e leve linguagem de declaração de página que é usada para construir visualizações em JSF usando estilos de templates HTML e

JPA 2.0: Criando tabelas - Parte 2

2011-03-03T23:32:00.037-04:00

Aproveitando o mesmo projeto da postagem da Parte 1: Este aqui vamos montar nossas classes para criar a seguinte estrutura do banco de dados: Para isso vamos usar as seguintes anotações que tratam as cardinalidades:@OneToOne@OneToMany@ManyToOnee tem a @ManyToMany que ficará para uma próxima postagem! No pacote model vamos criar as classes: Endereco.java, Categoria.java, Dependente.java e alterar

JavaEE 6: Bean Validation 1.0

2011-03-02T21:35:00.001-04:00

A especificação do JEE 6, criou uma validação padrão para os JavaBeans, que foi o Bean Validation 1.0. O que isso faz? bom.. a partir de anotações na classe de modelo, você consegue validar campos numéricos, definir se datas informadas serão obrigatoriamente maiores ou menores que a data atual, se o campo pode ser vazio ou não, assim ao dar o submit no form ele já valida esses campos, não

JavaEE 6: CRUD em JSF 2.0

2011-02-21T12:29:00.007-04:00

Inicialmente no banco de dados crie uma database chamada 4tads, e nela crie uma tabela cliente com o seguinte código: CREATE TABLE `4tads`.`cliente` ( `codigo` INTEGER(11) NOT NULL AUTO_INCREMENT, `nome` VARCHAR(255) NOT NULL, `telefone` VARCHAR(30) , PRIMARY KEY (`codigo`) ) ENGINE = InnoDB; Agora crie um projeto JEE 6 (Veja aqui), com o nome de crudJSF, teremos como estrutura

JPA 2.0: Criando tabelas - Parte 1

2011-02-17T01:34:00.005-03:00

Para trabalhar com o JPA, vamos usar a implementação padrão para a versão 2.0, o EclipseLink com o banco de dados MySQL. Antes de começar vamos preparar nosso banco de dados para receber nossas tabelas que serão geradas pelo JPA, então no banco de dados crie uma database com o nome de 5tads. Depois de criar um projeto Java EE6 (Veja aqui), vamos começar a utilizar o JPA. Inicialmente criei um

JPA 2.0: Java Persistence API

2011-02-04T00:08:00.001-03:00

Java Persistence API ou JPA, é uma especificação padrão do Java para persistência de dados que deve ser implementada por frameworks que queiram seguir o padrão. A JPA lida com a forma como os dados relacionais são mapeado para objetos Java ("entidades persistentes"), a maneira que esses objetos são armazenados em um banco de dados relacional, para que eles possam ser acessados em um momento

JavaEE 6: Utilizando Servlets 3.0

2011-01-28T06:55:00.003-03:00

Para quem já teve que fazer servlets em JEE 5, sabe o quanto é chatinho ter que ficar mapeando estas no arquivo web.xml. Pois bem, a especificação JEE 6 veio para facilitar nossa vida em relação a isso e muitas outras coisas, mas agora vamos tratar da servlet... bom, essa facilidade dá-se pelo fato de que não é mais necessário mapear a servlet no web.xml, agora existe uma anotação do pacote

JavaEE 6: Criando um projeto no NetBeans

2011-01-10T18:10:00.001-03:00

A partir do nosso ambiente de trabalho (clique aqui) vamos montar nosso primeiro projeto em JEE 6, com JSF 2.0 em quatro passos, basta apenas seguir as imagens.No NetBeans, crie um novo projeto da seguinte forma...Passo 1: Crie uma AplicaçãoWeb, que está na categoria Java Web Passo 2: Informe um nome para o projeto, este eu estou chamando de HelloWorldPasso 3: Marque a opção "Habilitar injeção de

JavaEE 6: Ambiente de trabalho

2011-01-06T22:20:00.002-03:00

Olá pessoal...! Para trabalhar com o JEE 6 o ambiente de trabalho é mais tranquilo do que o JEE5, vamos usar: Ferramenta: NetBeans 6.9.1 Servidor de aplicação: GlassFish 3.0 Banco de dados: MySQL Eu digo que é mais tranquilo porque o servidor de aplicação já vem embutido no NetBeans, o que facilita muito! Para baixar o NetBeans: http://netbeans.org/downloads/index.html Segue abaixo a tela de

JavaEE 5: SelectOneMenu (comboBox) em JSF 1.2

2010-12-29T22:25:00.001-03:00

Na postagem de hoje iremos fazer um SelectOneMenu ou como a maioria conhece ComboBox em JSF 1.2, numa mesma página teremos um dinâmico onde a lista vem de um bean e um estático onde os itens são definidos diretamente no código fonte da página. Segue a imagem: Segue o código fonte do ClienteBean: import java.util.ArrayList; import java.util.List; import javax.faces.model.SelectItem; public

JavaEE 5: CRUD em dialogs com PrimeFaces 1.1

2010-11-14T23:04:00.005-03:00

A postagem de hoje pode ser considerada uma alternativa para a essa postagem: CRUD em páginas com PrimeFaces 1.1 O que difere é que invés da navegação de páginas, nós teremos nosso CRUD em uma única página, em p:dialog, e nossos avisos de sucesso ou falha se darão através do p:growl(justamente o mesmo utilizado para informar os campos obrigatórios) não haverá necessidade de em caso de falha,

JavaEE 5: CRUD em páginas com PrimeFaces 1.1

2010-10-31T10:37:00.006-03:00

Esta postagem não difere muito desta: CRUD em JSF, o que difere é que teremos um pouco mais que um HTML puro como visualização, estaremos utilizando o PrimeFaces para criar a tabela com paginação e ter o inserir, alterar e remover dentro de painéis. Então, inicialmente a diferença do link acima é que nesta postagem estaremos utilizando valores como: double e java.util.Date, para mostrar que

JavaEE 5: Configuração do PrimeFaces em páginas JSP

2010-10-24T22:18:00.006-03:00

Informações: JSF 1.2, PrimeFaces 1.1: Clique para baixar o PrimeFaces 1.1 Porque não utilizar a versão que está no site do PrimeFaces? Pois a versão que está no site para baixar é para o JSF 2.0, causando assim uma incompatibilidade de versões, atualmente a versão mais atualizada para o JSF 1.2, realmente é a 1.1. Configurando.. Nessa configuração estou levando em consideração que já tenha um

JavaEE 5: CRUD em JSF 1.2

2010-10-18T21:52:00.006-03:00

Na postagem de hoje iremos fazer um CRUD - uma aplicação simples com as seguintes operações: Create(criar ou inserir), Retrieve(recuperar ou listar), Update(atualizar) e Delete(remover). Antes de começar vamos refrescar a memória: JavaServer Faces ... Criando o projetoNo Eclipse crie um novo 'JSF Project' como no link acima e coloque o nome de ProjetoJsf. Segue a estrutura do projeto: Nesse post

JavaEE 5: JavaServer Faces 1.2

2010-10-05T00:56:00.001-04:00

JavaServer Faces... o que é?É um framework MVC para o desenvolvimento de aplicações Web criado pela Sun, que permite o desenvolvimento de aplicações para a internet de forma visual, ou seja, arrastando e soltando os componentes na tela (em páginas JSP, quando utilizado sem outros frameworks, por exemplo: JBoss Seam), definindo as propriedades dos mesmos. (Wikipédia)Atualmente está na versão

JavaEE 5: CRUD com JSP e Servlet - Parte II

2010-09-20T12:53:00.000-04:00

Continuando a aula do dia 18/08/2010, vamos implementar o alterar e o remover de nossas categorias.Altere a página index.jsp, para que ela fique com o seguinte código: Depois de salvar as alterações o resultado é o seguinte:Perceba que foram adicionados dois links: um para a página alterarCategoria.jsp e outro para a removerCategoria.jsp, ambos passando o código da categoria por parâmetro na

JavaEE 5: CRUD com JSP e Servlet - Parte I

2010-09-15T23:49:00.000-04:00

Este é um exemplo de uma inserção de uma categoria qualquer... Com o eclipse todo configurado(aula do dia 04/08/2010), vamos criar um projeto web: No Eclipse vá em File - New - Dynamic Web Project Depois de criar o projeto, vamos configurar a aplicação para conectar ao banco de dados MySQL, para que isso ocorra precisaremos do driver JDBC para MySQL encontrado em: http://dev.mysql.com/downloads/

JavaEE 5: Ambiente de trabalho

2010-09-10T10:22:00.000-04:00

Como servidor de aplicação usaremos o JBoss: é um dos servidores de aplicações mais completos, também é capaz de trabalhar com as tecnologias mais modernas e possui frameworks incorporados a sua distribuição(ex: JSF e Hibernate, estes serão utilizados mais a diante).Para trabalhar com Java EE, utilizaremos a ferramenta de desenvolvimento Eclipse, que possui um pluguin que controla as

JavaEE: Servlets

2010-09-05T03:14:00.000-04:00

Quando se trata do desenvolvimento de aplicações web em linguagem de programação Java, deve-se conhecer os servlets, pois os mesmos são a base nesse tipo de desenvolvimento. Esta tecnologia, é a base para outra tecnologia Java, conhecida como JavaServer Pages (será estudada na próxima aula). De forma mais simples, os servlets são classes que dinamicamente processam requisições(request) e

JavaEE: Conceitos básicos

2010-09-01T19:32:00.001-04:00

Aplicações WebAplicações desse tipo são executadas a partir de navegadores de Internet (ex: Internet Explorer, Firefox...). Não necessitam de instalação na maquina dos clientes, são instaladas e executadas em servidores. Isso facilita na atualização e na manutenção do código fonte, já que o mesmo fica num único lugar, e ao ser atualizado essa atualização fica disponível na mesma hora para todos

Swing: Preenchendo um JComboBox

2010-08-24T21:21:00.009-04:00

Nesse post iremos preencher um JComboBox com objetos, para isso vamos precisar de uma java.util.List.Para exemplo vamos usar uma categoria. Então... precisamos de uma classe chamada Categoria.java public class Categoria { private int codigo; private String nome; public int getCodigo() { return codigo; } public void setCodigo(int codigo) { this.codigo =

JavaSE: Converter java.util.Date para String e vice-versa

2010-08-18T21:28:00.001-04:00

Converter String para java.util.DatePara converter uma String em java.util.Date, é necessário utilizar a classe java.text.SimpleDateFormat, passado uma String por parâmetro que se refere ao formato em que se encontra a String que será convertida: SimpleDateFormat formataData = new SimpleDateFormat("dd/MM/yyyy"); Date dataEntrada = null; try { dataEntrada = formataData.parse("21/09/2010"); }

JavaSE: CRUD em Swing

2010-08-15T21:22:00.001-04:00

Neste post, iremos implementar parte do projeto do Hotel da postagem: UML: Trabalhando com a diagramação . Este sistema será implementado em Java SE (para Desktop), com armazenamento em estruturas de dados (mais especificamente em java.util.List).O sistema final terá a seguinte estrutura: Obs: as classes do pacote model são as mesmas criadas na aula citada no link acima.Mas, neste post será

Collections: Estruturas de dados

2010-08-10T18:27:00.090-04:00

São tipos de dados compostos, diferentemente dos tipos: int, double, float, entre outros que são tipos de dados primitivos. As estruturas de dados são formas de armazenamento de dados ou objetos. Por exemplo, os arrays são estruturas de dados lineares e estáticas para armazenar dados, porém com capacidade limitada, ou seja deve-se inicializá-lo com um tamanho. Para aumentar essa capacidade

UML: Trabalhando com a diagramação

2010-08-05T18:19:00.007-04:00

Dado o seguinte cenário:"Um grande hotel dispõe de apartamentos para os seus hóspedes. Cada aposento tem seu valor e um numero para identificação. Ao ser feito a hospedagem, caso o hóspede não esteja cadastrado, o mesmo deve ser realizado. Na hospedagem devem constar dados como: data de entrada e data de saída, além de que a hospedagem pode ter mais de um aposento. Uma hospedagem tem uma conta, é

Análise: Conceitos de documentação de sistemas

2010-08-01T18:05:00.001-04:00

Análise de Requisitos “a análise de requisitos está associada ao processo de descobrir quais são as operações que o sistema deve realizar e quais são as restrições que existem sobre elas”. (WAZLAWICK, 2004)Esta é a fase em que o analista senta com o cliente para fazer o levantamento das funcionalidades do sistema e as restrições que existe sobre elas. Exemplos: Requisito funcional: “O sistema

[OFF] PyXiS: Sistema de Avaliações Online!

2010-07-31T14:19:00.003-04:00

Aqui vai uma descrição do que foi meu sistema defendido em banca para minha formação de tecnóloga, com orientação de Giovanni David Mazzoneto. ---------------------------------------- Resumo Este trabalho foi elaborado com a intenção de ajudar professores e alunos nos processos de elaboração (professor), resolução (aluno) e principalmente correção de avaliações (professor) quando descritivas,