Introdução à java persistence api – JPA

saudações java!

após algum tempo de estouro do hibernate, surge o java persistence api, sendo muito utilizado na comunidade para a camada de persistência.

O JPA é um framework utilizado na camada de persistência (ver figura 01) para o desenvolvedor ter uma maior produtividade, com impacto principal num modo para controlarmos a persistência dentro de java. pela primeira vez, nós, desenvolvedores temos um modo “padrão” para mapear nossos objetos para os do banco de dados. persistência é uma abstração de alto-nível sobre jdbc.

jpa
figura 01.

o java persistence api – JPA define um caminho para mapear plain old java objects pojos para um banco de dados, estes pojos são chamados de beans de entidade. beans de entidades são como qualquer outra classe java, exceto que este tem que ser mapeado usando java persistence metadata, para um banco de dados.

a nova java persistence specitication define mapeamento entre o objeto java e o banco de dados utilizando orm, de forma que beans de entidade podem ser portados facilmente entre um fabricante a outro.

o que é orm?

em resumo, mapeamento objeto/relacional é automatizado (e transparente) persistência de objetos em aplicações java para tabelas em um banco de dados relacional, usando metadata que descreve o mapeamento entre os objetos e o banco de dados.

para uma simples comparação, vamos dá uma olhada em dois códigos para demostrar como JPA é muitissímo utíl para uma aplicação java. primeiro irei criar um exemplo utilizando jdbc, e um outro utilizando JPA.

segue a estrutura da tabela:

create table bug (

id_bug int(11) not null auto_increment,

titulo varchar(60) not null,

data date default null,

texto text not null,

primary key (id_bug)

);

na utilização do JPA é necessário o os dois jar’s do toplink:

toplink-essentials.jar e o toplink-essentials-agent.jar

link para download:

http://www.oracle.com/technology/products/ias/toplink/JPA/download.html

adicione esses dois jar’s no classpath do seu projeto, e adicione também o driver jdbc do seu banco 😉

vamos dá uma olhada no código utilizando jdbc.

listagem 01. jdbccode.java.

package jdbc;

import java.sql.*;

/**

*

* @author adm

*/

public class jdbccode {

private static connection con = null;

/** creates a new instance of jdbccode */

public jdbccode() {

}

public static connection open(){

string user = “root”;

string pass = “123456”;

string url = “jdbc:mysql://localhost/bug”;

try{

class.forname(“com.mysql.jdbc.driver”);

con = drivermanager.getconnection(url,user,pass);

}catch( exception e ){

e.printstacktrace();

}

return con;

}

public static void main( string args[] ) throws exception{

string sql = “select * from bug”;

con = open();

try {

statement st= con.createstatement();

resultset rs= st.executequery(sql);

while( rs.next() ){

system.out.println(“titulo: “+ rs.getstring(“titulo”));

}

} catch (sqlexception ex) {

ex.printstacktrace();

}finally{

con.close();

}

}

}

uma classe bem simples, que lista os titulos dos bugs, mas são muitas linhas para escrever…. agora vamos dá uma olhada no código para selecionar um determinado registro utilizando JPA.

listagem 02. sniped code.

public object findbypk( int pkey ) {

entitymanager em = getentitymanager();

return em.find(bug.class, pkey);

}

pronto!!! mas isso é só para você comparar como nós ganhamos produtividade na camada de persistência, e portanto tendo mais tempo para os objetos da lógica negócio.

agora vamos ao exemplo real, segue o objeto bug ou o entity bean bug:

nossa classe deve implementar serializable e ter um campo id. os arrobas em cima dos atributos, são as anotações para mapear o seu objeto para a tabela bug.

a figura 02 mostra o mapeamento entre o objeto java e a tabela no banco de dados.
figura 02.

listagem 03. bug.java.

/*

* bug.java

*

*/

package exemplo;

import javax.persistence.*;

/**

*

* @author wendell miranda

*/

@entity

@table(name=”bug”)

public class bug implements java.io.serializable {

private integer id_bug;

private string titulo;

private java.util.date data;

private string texto;

/** creates a new instance of bug */

public bug() {

}

/*

a notação @generatedvalue(strategy=generationtype.sequence) informa que o id será gerado automaticamente pelo db.

*/

@id

@generatedvalue(strategy=generationtype.sequence)

@column(name=”id_bug”)

public integer getid_bug() {

return id_bug;

}

public void setid_bug(integer id_bug) {

this.id_bug = id_bug;

}

@column(name=”titulo”)

public string gettitulo() {

return titulo;

}

public void settitulo(string titulo) {

this.titulo = titulo;

}

@temporal(temporaltype.date)

@column(name=”data”)

public java.util.date getdata() {

return data;

}

public void setdata(java.util.date data) {

this.data = data;

}

@column(name=”texto”)

public string gettexto() {

return texto;

}

public void settexto(string texto) {

this.texto = texto;

}

@override

public string tostring(){

return “id: “+this.id_bug;

}

}

conclusões

utilizar java persistence api facilita muito o trabalho do desenvolvedor java, principalmente quando lidamos com muitas tabelas. este artigo foi apenas para quem nunca utilizou JPA e gostaria de saber um pouco sobre a tecnologia, no próximo artigo irei demonstrar um exemplo persistindo, atualizando, excluindo e listando os bugs.

referências

http://www.oreilly.com/catalog/entjbeans5/

http://www.oracle.com/technology/products/ias/toplink/JPA/tutorials-index.html

http://www.oracle.com/technology/products/ias/toplink/JPA/tutorials/jsf-JPA-tutorial.html

Como criar um JFrame com imagem de fundo

Imagens de fundo (backgrounds) são extremamente essenciais para certos layouts. Um simples gradient ou uma marca d’água representam um grande diferencial e tornam a aplicação mais agradável.

 

Infelizmente, o componente JFrame, até a versão 6.0 do JDK, não possui uma propriedade específica que possibilite configurar uma imagem como plano de fundo. Nesse caso é necessário implementar uma maneira, das várias possíveis, para disponibilizar esse recurso.

 

Definindo uma imagem de fundo

Para o exemplo do artigo, será usada uma imagem simples representando um gradient com dimensões 1024×768, que é a resolução mais utilizada atualmente nos desktops e armazenada no “C:\” como indica a Figura 01.

 

ascjfiffig01.jpg

Figura 01

 

O caminho da imagem que será utilizado pelo Java nesse caso será: “C:\bg_gradient.jpg”.

 

O método paintComponent

Como citado anteriormente, para se criar a possibilidade de definição de uma imagem de fundo, é necessário implementá-la manualmente.

 

Os JFrames possuem uma propriedade chamada contentPane que é o componente padrão onde são adicionados todos os componentes específicos como botões, labels, áreas de texto, etc.

 

Este contentPane possui um método chamado paintComponent que é o método responsável por desenhá-lo (o que é exibido para o usuário). E é ele quem será implementado.

 

A Listagem 01 exibe uma private class que será utilizada mais adiante no artigo. Primeiramente é interessante focar na implementação de paintComponent.

 

private class NewContentPane extends JPanel{

//método implementado de JPanel

protected void paintComponent(final Graphics g) {

               super.paintComponent(g);

               g.drawImage(bImage, 0, 0, this);

        }

}

Listagem 01 – Classe interna que implementa paintComponent

 

A classe interna NewContentPane é uma classe filha de JPanel e será o novo contentPane de JFrame.

 

Super.paintComponent(g) chama o respectivo método, porém, de JPanel, para que não sejam perdidas as visualizações-padrão de um JPanel. Em seguida, o método drawImage “desenha” bImage (imagem utilizada como background – descrita na próxima etapa do artigo).

 

Com isso tem-se uma classe filha de JPanel, porém com uma imagem desenhada ao invés de uma cor padrão.

 

O JFrame com o novo contentPane

Será desenvolvido agora o JFrame adaptado com o novo contentPane.

 

A Listagem 02 representa o código-fonte da classe JFrameWithBackground com a classe interna criada anteriormente.

 

package br.com.jm.jframes;

 

import java.awt.Graphics;

import java.awt.Image;

import java.awt.Toolkit;

 

import javax.swing.JFrame;

import javax.swing.JPanel;

 

public class JFrameWithBackground extends JFrameFactory{

       

        Image bImage;

       

        public JFrameWithBackground(String path){

               this.bImage = this.createImage(path);

               this.initComponents();

        }

       

        public void initComponents(){

               super.setContentPane(new NewContentPane());

               super.setExtendedState(JFrame.MAXIMIZED_BOTH);              

        }

       

        private Image createImage(String path){

               return Toolkit.getDefaultToolkit().createImage(path);

        }

       

        private class NewContentPane extends JPanel{

               protected void paintComponent(final Graphics g) {

                       super.paintComponent(g);

                       g.drawImage(bImage, 0, 0, this);

               }

        }

}

Listagem 02 – JFrameWithBackground

 

O construtor da classe recebe uma String que representa o caminho da imagem e em seguida chama o método createImage. Esse método chama a função createImage da classe Toolkit (java.awt.Toolkit) que retorna uma imagem de acordo com esse caminho. A variável, anteriormente citada, bImage agora representa a imagem de fundo do JFrame.

 

É dentro do método initComponents que se faz a alteração do contentPane que agora será uma instância de NewContentPane (classe interna criada no início do artigo e que implementa paintComponent).

 

Como isso tem-se um JFrame que possui um contentPane diferente do padrão; que possui uma imagem de fundo.

 

Testando o novo JFrame

Falta apenas testar o novo JFrame e sua nova capacidade (possuir uma imagem de fundo). A Listagem 03 exibe uma classe simples com um panel adicionado.

 

import java.awt.BorderLayout;

import java.awt.Dimension;

 

import javax.swing.BorderFactory;

import javax.swing.JLabel;

import javax.swing.JPanel;

import javax.swing.JScrollPane;

import javax.swing.JTextArea;

import javax.swing.UIManager;

 

import br.com.jm.jframes.JFrameWithBackground;

 

public class TesteJFrameWithBackground {

        public static void main(String[] args) {

               try{

                       UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());

               } catch(Exception exception){

                      

               }

              

               JPanel jPanel3 = new JPanel(new BorderLayout());

               jPanel3.add(new JLabel(“teste-background”), BorderLayout.NORTH);

               jPanel3.add(new JLabel(“texto:”), BorderLayout.WEST);

               jPanel3.add(new JScrollPane(new JTextArea()), BorderLayout.CENTER);

               jPanel3.add(new JLabel(“teste-background-fim”), BorderLayout.SOUTH);

               jPanel3.setPreferredSize(new Dimension(400,500));

               jPanel3.setBorder(BorderFactory.createTitledBorder(“jPanel3”));

               jPanel3.setOpaque(false);

              

               JFrameWithBackground jFrame = new JFrameWithBackground(“C:\\bg_gradient.jpg”);

               jFrame.setLayout(new BorderLayout());

               jFrame.getContentPane().add(jPanel3, BorderLayout.NORTH);

               jFrame.setVisible(true);

        }

}

Listagem 03 – Classe de testes

 

A imagem passada como parâmetro para JFrameWithBackground é a citada no início do artigo.

 

Conclusão

Implementando paintComponent de JPanel e armazenando essa implementação como novo contentPane de um JFrame foi possível criar um frame com uma imagem de fundo. À medida que essa nova classe vai sendo desenvolvida, pode-se criar métodos set e get que permitam atualizar, em tempo de execução, a imagem de fundo, tornando-a dinâmica.

 

Um grande abraço,

Adriano S. Castro

Escrevendo em arquivo texto

Autor: Mayron Cachina – estudante do curso de Sistemas de Informação na Universidade Potiguar – UnP, atuando no desenvolvimento de sistemas em JAVA, Delphi e PHP.

Pessoal uma pequena aplicação para exercitar a escrita de arquivos…
Tive algumas duvidas no começo de como ler todo o vetor e retirar as strings com duplicidade…
mais ai está de um modo simples, fácil e descomplicado…
Estou disponibilizando os fontes (no Netbeans) para download.


package br.com.dragon.utils.lerArquivo.exec;

import java.io.*;
import java.util.*;

public class Main {
public String file;
public static String origem;
public static String destino;

public Main(String file){
this.file = file;
}

public void lerTexto() throws IOException{
// VARIÁVEL ONDE SERÁ GUARDADA A LINHA PERCORRIDA
String line = “”;
// Usamos os BufferedReader para abrir o arquivo.
BufferedReader  bf = new BufferedReader(new FileReader(this.file));
// Instanciamos uma collection para guardar o nosso conteúdo
Collection lista = new ArrayList();
// variáveis para contagem de linhas (só pra ficar mais bonitinho, hehehe)
int linhaT = 0;
int linhaF = 0;

/* AQUI SERÁ ONDE VAMOS PREENCHER NOSSA LISTA */
while ((line = bf.readLine()) != null)  {
System.out.println(“PERCORRENDO LINHA: ” + linhaT++);
// COMANDO PRA PREENCHER A LISTA “line”
lista.add(line);
}

/* AQUI SERÁ O TRATAMENTO
* DA LISTA A SER SALVA
* SEM REPETIÇÕES….
*/
// O MÉTODO “LinkedHashSet” SERVE PARA NÃO EMBARALHAR A LISTA
// QUE NO CASO O COMANDO “HashSet” faz…
Collection lista2 = new LinkedHashSet(lista);
// CRIA O NOVO ARQUIVO ONDE SERÁ ARMAZENADA A LISTA
File arquivo = new File(destino);

// ABRE O ARQUIVO DE DESTINO PARA A GRAVAÇÃO
BufferedWriter bw = new BufferedWriter(new FileWriter(arquivo));
// PERCORRE TODA A NOVA LISTA
for (Object item : lista2){
linhaF++;
/* ESCREVE A LISTA NO ARQUIVO…
* OBSERVE O TYPECAST FEITO POIS O
* FOR ESTÁ PASSANDO UM “Object”
*/
bw.write((String) item);
bw.newLine();
}

bw.flush();
bw.close();

System.out.println(“VARREDURA COMPLETA…”);
System.out.println(“TOTAL DE LINHAS NOVO ARQUIVO: ” + linhaF);
}

public static void main(String[] args) {
origem  = args[0];
destino = args[1];

Main l = new Main(origem);

try{
l.lerTexto();
}catch (IOException ioe) {
ioe.printStackTrace();
}
System.out.println(“CONCLUIDO…”);
}
}

Conhecendo o Ajax4Jsf

Rafael de Paula Souza (rafael.bnc@gmail.com), está cursando Engenharia de Computação na FURG. Atualmente faz estágio na área de soluções para Web em Java, utilizando JSF e demais frameworks.

Introdução

Ajax4Jsf é um framework que adiciona capacidade Ajax nas aplicações que utilizam JSF sem recorrer ao JavaScript. O principal objetivo do framework é fazer chamada das Actions ou ActionListeners no Managed Bean de forma assíncrona, obedecendo todo ciclo de vida do Faces, e depois fazendo uma atualização de um ou mais componentes especificados nos atributos da tag.

 

Instalação

A instalação do Ajax4Jsf é muito fácil, para isso basta seguir os passos a seguir.

·         Fazer download da distribuição em – http://labs.jboss.com/portal/jbossajax4jsf

·         Copiar os Jars “ajax4jsf-1.1.0.jar” e “oscache-2.3.2.jar” do Ajax4Jsf para a pasta WEB-INF/lib da sua aplicação.

·         Adicionar as configurações do filter do Ajax4Jsf no arquivo web.xml.  

·         Importar o ajax4jsf nas paginas da sua aplicação.

 

 

Configurando o web.xml

Adicione a seguinte configuração no arquivo web.xml:

<context-param> 

        <param-name>org.ajax4jsf.SKIN</param-name>

        <param-value>classic</param-value> 

</context-param>

<filter> 

<display-name>Ajax4jsf Filter</display-name>

<filter-name>ajax4jsf</filter-name>

<filter-class>org.ajax4jsf.Filter</filter-class> 

</filter>

<filter-mapping>

<filter-name>ajax4jsf</filter-name>

<servlet-name>Faces Servlet</servlet-name>

<dispatcher>REQUEST</dispatcher>

<dispatcher>FORWARD</dispatcher>

<dispatcher>INCLUDE</dispatcher>

</filter-mapping>

 

E para importar o ajax4jsf na sua pagina jsp use:

<%@ taglib uri=https://ajax4jsf.dev.java.net/ajax&#8221; prefix=“a4j”%>

 

Se você estiver trabalhando com facelets:

<xmlns:a4j=https://ajax4jsf.dev.java.net/ajax&#8221;>

 

AJAX Requests

Existem diferentes formas para fazer que suas paginas enviem AJAX requests. Para isso, você pode usar as seguintes tags: <a4j:commandButton>, <a4j:commandLink>, <a4j:poll> e <a4j:support>.

 

Essas tags escondem do programador o JavaScript que é necessário para enviar AJAX requests,  o que facilita muito o desenvolvimento de aplicações que utilizam essa tecnologia. Elas também permitem que você escolha quais componentes de sua pagina que serão “modificados” após o AJAX response (você pode listar os IDs desses componentes através do atributo “reRender”).

 

<a4j:commandButton> e <a4j:commandLink>: essas tags são usadas para enviar AJAX request através do evento “onclick”.

<a4j:poll>: usada para enviar AJAX request em um determinado tempo.

<a4j:support>: permite que qualquer componente JSF faça AJAX request através de um determinado evento JavaScript: “onkeyup”, “onmouseover”, etc.

 

Exemplos:

<h:inputText value=“#{pessoa.nome}”>

        <a4j:support event=“onkeyup” reRender=“texto”/>

</h:inputText>

<h:outputText id=“texto” value=“#{pessoa.nome}”/>

 

 

<h:form id=”form”>

        <h:inputText value=“#{pessoa.nome}”/>

        <h:inputText value=“#{pessoa.rg}”/>

        <h:inputText value=“#{pessoa.cpf}”/>

        <a4j:commandButton reRender=“form” action=“#{pessoa.atualizar}” value=“Atualizar” oncomplete = “alert(‘Dados atualizados’)”/>

</h:form>