Java

Java, acessando banco de dados MS-Access em Windows 64bits

Posted on fevereiro 2, 2013. Filed under: Access, Java | Tags:, , , |

Introdução

Neste artigo vamos aprender como acessar um banco de dados MS-Access pelo Java. No caso, estaremos com o Windows instalado em uma arquitetura 64bits. Mesmo estando na arquitetura 64bits, o Windows ainda distribui os drivers ODBC do MS-Access em arquitetura 32bits (Pelo menos no Windows 7). Portanto, para que o Java possa usar o driver ODBC do Ms-Access, teremos que rodar o Java em uma JVM de arquitetura 32bits.

Configurando o ODBC

O primeiro passo é configurar um data source no administrador de fonte de dados ODBC do Windows. Como estamos usando o Windows 64bits, abra o odbcad32.exe no seguitne caminho:
C:\Windows\SysWOW64\odbcad32.exe

PS: Não acesse o odbcad32.exe dentro do diretório System32, pois não funcionará corretamente devido a arquitetura do Windows ser 64bits.

Após aberto o gerenciador de fonte de dados, clique na aba “Fonte de dados do Sistema”, em seguida, clique no botão Adicionar, para adicionar uma nova fonte de dados.

ScreenShot048

Selecione o Microsoft Access Driver como tipo de driver para fonte de dados. No meu caso, preciso conectar em um banco de dados MS-Access com extensão .accdb:

ScreenShot049

Na próxima tela informe o nome da fonte de dados. Esse nome será usado para identificar o banco de dados na hora do acesso (Vamos usar esse nome em nosso programa Java).

Clique no botão Selecionar e escolha o banco de dados MS-Access. (No meu caso é um arquivo com extensão .accdb) e clicar em OK:

ScreenShot050

Criando o aplicativo Java

O código abaixo é um exemplo de como fazer o Java conectar em um banco de dados MS-Access. Verificar no próprio código, os comentários para qualquer dúvida.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;


/**
 * Classe responsável por gerenciar conexões com banco de dados MS-Access
 * @author Douglas.Pasqua
 *
 */
public class AccessConnect {
	private static final String username = "";
	private static final String password = "";
	private static final String DSN = "DatabaseUsuarios"; // nome da fonte de dados
	private static final String driver = "sun.jdbc.odbc.JdbcOdbcDriver"; // driver usado
	private static Connection conn = null;
	        
	/**
	 *  retorna uma conexão com o banco de dados Access. 
	 *  Utiliza o Design Pattern Singleton
	 */ 
	public static Connection getConnection() throws Exception {
	    if(conn == null) {
	        String url = "jdbc:odbc:" + DSN;
	        Class.forName(driver);
	        conn = DriverManager.getConnection(url, username, password);
	    }
	    return conn;
	}
	
	/**
	 * Fecha a conexão com o Banco de dados access
	 * Chamar esse método ao sair da aplicação
	 */
	 public static void close() {
        if(conn != null) {
            try {
                conn.close();
            } catch (SQLException ex) {
                ex.printStackTrace();
            } finally {
                conn = null;
            }
        }
    }
	
	/**
	 * Exemplo de teste da classe de conexão com o 
	 * Access
	 */
	public static void main(String[] args) {
		try {
			// inicilizando a conexão
			Connection conn = AccessConnect.getConnection();

			Statement st = conn.createStatement();
            ResultSet rs = st.executeQuery("SELECT nome FROM usuario"); // temos uma tabela usuario com o campo nome
            while(rs.next()) {
            	String nome = rs.getString("nome");
                System.out.println("Nome: " + nome);
            }
            
            // fechando a conexão
			AccessConnect.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

Ao executar o código acima, caso esteja em uma arquitetura 64bits, provavelmente a jvm usada também estará em 64bits, você obterá a seguinte Exception:

java.sql.SQLException: [Microsoft][ODBC Driver Manager] O DSN especificado contém uma incompatibilidade de arquiteturas entre o Driver e o Aplicativo

Como os drivers nativos do MS-Access no windows são 32bits e você esta executando o código em uma virtual machine do java em 64bits, será gerado o Exception acima. Para que você possa rodar o aplicativo sem erros, é necessário instalar o JRE do java para 32bits.

Instalando o JRE para 32bits

Para instalar o JRE versão 32bits para windows, acesse o link abaixo primeiramente:
http://www.oracle.com/technetwork/java/javase/downloads/index.html

Clique no download de JRE na versão desejada. Na próxima tela escolha a versão do java para x86. Exemplo:
jre-7u11-windows-i586.exe

Não se preocupe caso já tenha outra versão do java instalada. Não haverá conflitos. Após a instalação do JRE para 32bits, o próximo passo é executar o seu aplicativo java com essa nova jvm recém-instalada. Veremos abaixo como fazer através de linha de comando, Netbeans e Eclipse.

Executando através de linha de comando

Executar o java de 32bits através da linha de comando é simples. Basta usar o comando java do JRE de 32bits recém-instalado.
(Lembre-se que o importante é executar o bytecode do java em arquitetura 32bits. O compilador do java, javac, pode estar em outra arquitetura)

"C:\Program Files (x86)\Java\jre7\bin\java" -cp . AccessConnect

Executando através do Netbeans

No diretório bin\ da instalação do Netbeans tem dois executáveis: Netbeans.exe e Netbeans64.exe ! Inicie o Netbeans usando o executável Netbeans.exe. Desas forma, ele usará uma jvm em 32bits para executar os arquivos java de dentro do IDE Netbeans.

ScreenShot051

Executando através do Eclipse

Primeiro, vamos configurar a JRE de 32bits instalada no processo anterior. O Eclipse permite que você configure quantas JRE forem necessárias. Depois, nas propriedades do projeto, você escolhe qual JRE deseja usar.

No Eclipse, clique em “Window -> Preferences” e depois no botão “Add”:

ScreenShot052

Na próxima tela, escolha “Standard VM” e clique em “Next”:

ScreenShot053

Na próxima tela, informe o caminho do JRE 32bits. Caso necessário, altere o campo JRE Name para não conflitar com outro JRE já instalado:

ScreenShot054

Para continuar clique em “Finish”. Depois na tela de “Preferences”, clique em Ok.

Em seguida, clique com o botão direito do mouse em cima do projeto que contém a aplicação de acesso ao Ms-Access que você deseja testar.
Vá em “Build Path -> Configure Build path”!

Na tela “Java Build Path”, clique na aba “Libraries”!

Clique na linha “JRE System Library” e em “Edit” para poder escolher o JRE que acabamos de configurar. Irá abrir uma nova tela para selecionar o JRE usado para fazer o build do projeto. No campo “Alternate JRE”, escolha a JRE que acabamos de configurar. Clique em “Finish”:

ScreenShot055

Pronto, agora você já pode rodar sua aplicação que conecta no MS-Access pelo Java.

Ler Post Completo | Make a Comment ( 8 so far )

Java, Remove OLE headers from images stored as OLE Objects in access database

Posted on janeiro 24, 2013. Filed under: Access, Java | Tags:, , |

If you are using Java to access a MS Access database, and need to retrieve images stored in fields of type OLE Object, then this post can help you. When you insert images into OLE Object fields directly using the MS Access client, and you need to retrieve this image later to use in a desktop application or a web site, you will have a problem. The problem, is that the MS Access insert an OLE Header in the image file registered in database. So you will need to remove the OLE Header to use the image out of the Ms Access. The code below acomplishes this task.

This post is based on:
http://blogs.msdn.com/b/pranab/archive/2008/07/15/removing-ole-header-from-images-stored-in-ms-access-db-as-ole-object.aspx

I just ported the code to Java language.

The code:

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;

/**
 * Class to remove OLE Header from images stored as OLE Object
 * @author Douglas.Pasqua
 */
public class OLEImage {
    
    // Map to store the initial block of different images formats
    private Map<String, String> imagesBeginBlock;

    public OLEImage() {
        // inicialize
        imagesBeginBlock = new HashMap<String, String>();
        imagesBeginBlock.put("JPEG", "\u00FF\u00D8\u00FF"); // JPEG
        imagesBeginBlock.put("PNG", "\u0089PNG\r\n\u001a\n"); // PNG
        imagesBeginBlock.put("GIF", "GIF8"); // GIF
        imagesBeginBlock.put("TIFF", "II*\u0000"); // TIFF
        imagesBeginBlock.put("BMP", "BM"); // BMP
    }
   
    public byte[] getByteImgFromOLEInputStream(InputStream input, String imageFormat) {
        // get begin block identifier using imageFormat parameter
        String beginBlock = imagesBeginBlock.get(imageFormat);
        if(beginBlock == null) {
            throw new RuntimeException("Unsupported image format parameter value.");
        }
        
        try {
            byte[] b = toByteArray(input);
            String str = new String(b, "ISO-8859-1");
            
            // identifying the initial position of the image 
            int index = str.indexOf(beginBlock);
            if(index == -1) {
                throw new RuntimeException("Unable to determine image format.");
            }
            
            // removing the OLE Header 
            byte[] buffer = new byte[b.length - index];
            for(int i = 0, a = index; a < b.length; i++, a++) {
                buffer[i] = b[a];
            }
            return buffer;
            
        } catch(IOException e) {
            e.printStackTrace();
        } 
        
        return null;
    }
    
    /**
     * Convert InputStream object to array of bytes
     * @throws IOException 
     */
    public byte[] toByteArray(InputStream is) throws IOException {
        int len;
        int size = 1024;
        byte[] buf;

        if (is instanceof ByteArrayInputStream) {
            size = is.available();
            buf = new byte[size];
            len = is.read(buf, 0, size);
        } else {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            buf = new byte[size];
            while ((len = is.read(buf, 0, size)) != -1) {
                bos.write(buf, 0, len);
            }
            buf = bos.toByteArray();
        }
        return buf;
    }
}

Examples of Use

Using with JPEG, PNG and GIF images on Desktop Applications

Java has native support for JPG, PNG and GIF images. So theses images format will work well with ImageIcon class:

// the class to remove de OLE Headers from OLE Objects
OLEImage oleImage = new OLEImage();

// get OLE object field from access database
// ...

// using with GIF format
InputStream input = rs.getBinaryStream("oleGIF");
byte buffer[] = oleImage.getByteImgFromOLEInputStream(input, "GIF");
ImageIcon icon = new ImageIcon(buffer);

// using with JPEG format
InputStream input = rs.getBinaryStream("oleJPEG");
byte buffer[] = oleImage.getByteImgFromOLEInputStream(input, "JPEG");
ImageIcon icon = new ImageIcon(buffer);

// using with PNG format
InputStream input = rs.getBinaryStream("olePNG");
byte buffer[] = oleImage.getByteImgFromOLEInputStream(input, "PNG");
ImageIcon icon = new ImageIcon(buffer);

Using TIFF and BMP Images on Desktop Applications

Our OLEImage class supports removing OLE Headers for TIFF and BMP images format too. But java doesn’t support these image formats natively. So, you can’t use these formats directly with ImageIcon.

If you are developing for desktop, you will need a alternative method to support these formats. The following links can help you with this task:

http://stackoverflow.com/questions/593830/display-bmp-in-jlabel
http://stackoverflow.com/questions/1567398/showing-tiff-images-in-java
http://stackoverflow.com/questions/9634472/how-to-set-tif-image-to-imageicon-in-java

Using all Image Formats on Web Applications

You are free to use any image format when working in web enviroment. (If you need to send these images from Access database to client browser).

Ler Post Completo | Make a Comment ( None so far )

Java Tips: Operações com JTable parte 3

Posted on dezembro 18, 2012. Filed under: Java, Tips | Tags:, |

Introdução

Vamos mostrar mais algumas dicas interessantes da class JTable do Java. Outras dicas do JTable podem ser encontradas nos posts anteriores:

Java Tips: Operações com JTable parte 1
Java Tips: Operações com JTable parte 2

  1. Manipulando o conteúdo da tabela
  2. 
    // inserindo dados em uma tabela com 4 colunas
    DefaultTableModel tableModel = (DefaultTableModel) minhaTabela.getModel();
    tableModel.insertRow(tableModel.getRowCount(), new Object[]{ "Douglas", "Villanacci", "douglas.pasqua@gmail.com", "11111111"});
    tableModel.insertRow(tableModel.getRowCount(), new Object[]{ "Fulano", "da Silva", "fulano.silva@blalbla.com", "11111111"});
    
    // limpando todo o conteúdo da tabela
    DefaultTableModel tableModel = (DefaultTableModel) minhaTabela.getModel();
    tableModel.getDataVector().removeAllElements();
    minhaTabela.updateUI();
    
    // alterando o valor de determinada linha e coluna da tabela: Linha (1), Coluna (1)
    // linha e coluna começam com valor 0
    TableModel model = (TableModel) minhaTabela.getModel();
    model.setValueAt("Josefina", 0, 0);
    
    // obtendo valor de determinado campo na tabela, informando Linha(2) e Coluna(1)
    // linha e coluna começam com valor 0
    TableModel model = (TableModel) minhaTabela.getModel();
    String value = (String) model.getValueAt(1, 0);
    System.out.println(value);
    
  3. Tratando evento de mudança de dados na tabela
  4. Caso você tenha campos editáveis na sua tabela, você pode em algum momento querer executar alguma ação quando um valor de um campo da sua tabela sofrer alterações.

    Para que você possa controlar as mudanças realizadas na edição da sua tabela, é necessário monitorar o evento de alteração através do listener TableModelListener.

    // monitorando o evento através de TableModelListener
    minhaTabela.getModel().addTableModelListener(new TableModelListener() {
        @Override
        public void tableChanged(TableModelEvent e) {
            int linha = e.getFirstRow();
            int coluna = e.getColumn();
    
            TableModel model = (TableModel) e.getSource();
    
            System.out.println("Você alterou a linha " + linha + ", coluna " + coluna);
            System.out.println("Valor da célula alterada: " + model.getValueAt(linha, coluna));
        }
    });
    
  5. Usando ComboBox (JcomboBox) nas células da sua tabela
  6. É possível associar um JComboBox (caixa de seleção) à uma coluna da sua tabela. É uma forma de facilitar a vida do usuário. Ao invés do usuário digitar um valor para a célula, ele simplesmente escolhe um valor dentre vários, através de uma caixa de seleção. Recurso bem interessante e elegante.

    No exemplo abaixo, vamos associar um combo box para a quinta coluna da tabela. (Lembre-se que a numeração das colunas começa por 0). O usuário poderá escolher entre “Masculino” ou “Feminino”:

    // Obtendo à referencia para a 5 coluna da tabela
    TableColumn column = minhaTabela.getColumnModel().getColumn(4);
    // Criando o ComboBox
    JComboBox comboSexo = new JComboBox();
    // Definindo os valores para o ComboBox
    DefaultComboBoxModel comboModel = new DefaultComboBoxModel(new String[] { "Masculino", "Feminino" });
    comboSexo.setModel(comboModel);
    // Associando o ComboBox para a coluna
    column.setCellEditor(new DefaultCellEditor(comboSexo));
    

    Veja ilustração:

    ScreenShot026

Ler Post Completo | Make a Comment ( None so far )

Java Tips: Download de arquivo usando Apache HttpComponents

Posted on junho 3, 2012. Filed under: Java, Tips | Tags:, , |

Introdução

Já vimos em um artigo anterior como realizar o download de arquivos binários através de HTTP usando a biblioteca Commons HttpClient do Apache. O Commons HttpClient foi descontinuado já à algum tempo e substituído pelo projeto Apache HttpComponents que promete melhor perfomance e mais flexibilidade. Portanto neste artigo vamos demonstrar como realizar o download de arquivos através de http usando a biblioteca HttpComponents.

Segue abaixo o código fonte:

import java.io.IOException;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;

// definição da classe HttpDownload 
public class HttpDownload {
	private final HttpClient httpclient;
	
	public static void main(String[] args) {
		// instanciando e usando a classe HttpDownload 
		HttpDownload httpDownload = new HttpDownload(new DefaultHttpClient());
		
		// fazendo o download do logotipo da google e salvando em diretório local 
		httpDownload.downloadByGet("http://www.google.com.br/images/srpr/logo3w.png", "/tmp/logo-google.png");
	}
	
	// construtor 
	public HttpDownload(HttpClient httpclient) {
		this.httpclient = httpclient;
	}
	
	// método que realiza download de arquivo via método GET 
	public void downloadByGet(String URL, String path) {
		HttpGet httpget = new HttpGet(URL);
		try {
			HttpResponse response = httpclient.execute(httpget);
			HttpEntity entity = response.getEntity();
								
			if (entity != null) {
				/* salvar arquivo no disco */
				java.io.FileOutputStream fos = new java.io.FileOutputStream(path);
			    entity.writeTo(fos);
			    fos.close();
			}
		} catch (ClientProtocolException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}
Ler Post Completo | Make a Comment ( 5 so far )

Java Tips: Operações com JTable parte 2

Posted on maio 24, 2012. Filed under: Java, Tips | Tags:, |

Introdução

Neste artigo teremos mais alguns exemplos de manipulação de tabelas do JTable do Java. Já abordamos o JTable em um artigo anterior. Portanto, este artigo serve como complemento ao anterior.

  • Bloqueando a seleção de linhas/colunas baseado em uma determinada condição.
  • int linhas = 10;
    int colunas = 3;
    JTable table = new JTable(linhas, colunas) {
    	public void changeSelection(int row, int column, boolean toggle, boolean extend) {
    		DefaultTableModel m = (DefaultTableModel) getModel();
    	
            /* não permite a seleção da linha quando o valor da coluna 3 for igual fechado */
    		if (m.getValueAt(row, 2) != null && m.getValueAt(row, 2).toString().toLowerCase().equals("fechado")) {
    	    	return;
    	    }
    		super.changeSelection(row, column, toggle, extend);
    	}
    };
    
  • Alterando o cor de fundo/primeiro plano de acordo com uma determinada condição.
  • Determina também a cor de fundo/primeiro plano da linha selecionada. Você esta livre para inserir outras lógicas que achar necessário além desse exemplo básico que verifica somente o valor de uma determinada coluna.

    int linhas = 5;
    int colunas = 3;
    JTable table = new JTable(linhas, colunas) {
        public Component prepareRenderer(TableCellRenderer renderer,
                int rowIndex, int vColIndex) {
    		
        	DefaultTableModel m = (DefaultTableModel) getModel();
        	Component c = super.prepareRenderer(renderer, rowIndex, vColIndex);
        	
        	// altera a cor de background da linha para vermelho e foreground para branco
        	// quando o valor da coluna 3 for igual a fechado 
        	if (m.getValueAt(rowIndex, 2).toString().toLowerCase().equals("fechado")) {
        		c.setBackground(new Color(192, 0, 0));
        		c.setForeground(Color.white);
            } else {
            	// mantem a cor padrão de foreground 
            	c.setForeground(getForeground());
            	
            	// determina a cor de background da linha selecionada 
            	if(isCellSelected(rowIndex, vColIndex)) {
            		c.setBackground(new Color(184, 207, 229));
            	} else {
            		// linhas não selecionadas, manter cor de background padrão 
            		c.setBackground(getBackground());
            	}
    
            }			
    		return c;
        }
    };
    

    Exemplo de visualização:

  • Forçar a renderização do JTable
  • O código abaixo pode ser utilizado para renderizar o JTable novamente quando for preciso. No caso de mudança de dados que influencie na lógica usada em algum dos métodos anteriores.

       
    table.updateUI();     
    

Mais dicas

Java Tips: Operações com JTable parte 1
Java Tips: Operações com JTable parte 3

Ler Post Completo | Make a Comment ( 1 so far )

Java Tips: Lendo Cookies de Requisição com HTTPClient

Posted on fevereiro 20, 2012. Filed under: Java, Tips | Tags:, , , , |

Nesta dica Java, vamos demonstrar como ter acesso aos cookies definidos por determinado site após efeutar uma requisição HTTP (GET ou POST). Para isso vamos usar a lib HttpClient do Apache, conhecida como Apache HttpComponents. Esta é a nova lib do Apache para trabalhar com requisições HTTP que foi re-escrita para substituir a antiga lib Commons HttpClient.

Para maiores detalhes sobre a nova lib HttpClient, acesse: http://hc.apache.org/

Ao desenvolver determinada aplicação, tive a necessidade de manipular os cookies de uma resposta de requisição. Tive dificuldade de achar algo simples na internet que me fosse realmente útil. Após conseguir o que eu queria com um certo esforço resolvi compartilhar essa dica com vocês. Portanto, segue ele abaixo.

O código abaixo esta bem documentado e de fácil entendimento. Torço para que seja útil.

import java.io.IOException;
import java.util.List;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.CookieStore;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.protocol.ClientContext;
import org.apache.http.cookie.Cookie;
import org.apache.http.impl.client.BasicCookieStore;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.protocol.BasicHttpContext;
import org.apache.http.protocol.HttpContext;
import org.apache.http.util.EntityUtils;

public class ShowCookies {

	public static void main(String[] args) {
				
		// instância da classe do client HTTP
		DefaultHttpClient client = new DefaultHttpClient();
		
		// objeto onde serão armazenados as informações relativas aos cookies 
		CookieStore cookieStore = new BasicCookieStore();

		// criação de um contexto utilizado nas requisições para que possamos acessar 
		// as informações dos cookies	
		HttpContext localContext = new BasicHttpContext();
		localContext.setAttribute(ClientContext.COOKIE_STORE, cookieStore);
	
		// instância o objeto HttpGet
		HttpGet httpget = new HttpGet("http://www.google.com/");
				
		try {
			// efetua a resquisição GET
			HttpResponse response = client.execute(httpget, localContext);
			
			// trabalha a resposta da requisição
			HttpEntity entity = response.getEntity();				
			if (entity != null) {
				String responseBody = EntityUtils.toString(entity);
				
				// exibe o conteúdo do corpo da resposta da requisição GET
				System.out.println(responseBody);
				
				// exibe os conteúdo dos cookies definidos pelo domínio
				List<Cookie> cookies = cookieStore.getCookies();
				for(Cookie cookie : cookies) {
					System.out.println("Cookie: " + cookie.getName() + "=" + cookie.getValue());
				}		
			}
		} catch (ClientProtocolException e) {
			e.printStackTrace();
			
		} catch (IOException e) {
			e.printStackTrace();
			
		}
	}
}
Ler Post Completo | Make a Comment ( None so far )

Java Tips: Operações com JTable

Posted on fevereiro 4, 2012. Filed under: Java, Tips | Tags:, , , |

Neste artigo reuni algumas operações úteis realizadas com o componente JTable do Java. Vamos à elas:

  • Instanciando um JTable, já inserindo dentro de um JScroll, que desabilita o usuário poder editar suas células:
int linhas = 10;
int colunas = 2;
JTable table = new JTable(linhas, colunas) {
    public boolean isCellEditable(int rowIndex, int vColIndex) {
             return false;
    }
};
JScrollPane scrollPane = new JScrollPane(table);
  • Bloqueia o usuário de redimensionar as colunas da tabela:
table.getTableHeader().setResizingAllowed(false);
  • Bloqueia o usuário de trocar a posição das colunas via drap and drop.
table.getTableHeader().setReorderingAllowed(false);
  • Alterando o nome das duas primeiras colunas da tabela dinâmicamente:
table.getColumnModel().getColumn(0).setHeaderValue("Coluna 1");
table.getColumnModel().getColumn(1).setHeaderValue("Coluna 2");
  • Definindo um tamanho fixo para largura das duas primeiras colunas:
table.getColumnModel().getColumn(0).setPreferredWidth(115);
table.getColumnModel().getColumn(1).setPreferredWidth(661);
  • Desativando o auto redimensionamento da tabela:
table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
  • Permite apenas seleção simples (somente 1 linha):
table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
  • Tratando evento de dois clicks do mouse em cima de uma linha da abela:
table.addMouseListener(new MouseAdapter() {
	   public void mouseClicked(MouseEvent e) {
	       if (e.getClickCount() == 2) {
	           JTable target = (JTable)e.getSource();
	           int linha = target.getSelectedRow(); // linha selecionada
	           int coluna = target.getSelectedColumn(); // coluna selecionada

	           System.out.println("Linha: " + linha);
	           System.out.println("Coluna: " + coluna);
	       }
	   } 
});

Espero que essas dicas possam ajudar você de alguma forma. Todas elas foram úteis para mim em algum momento, portanto achei importante compartilhar.

Mais dicas

Java Tips: Operações com JTable parte 2
Java Tips: Operações com JTable parte 3

Ler Post Completo | Make a Comment ( None so far )

Java Tips: Gerando hash MD5

Posted on janeiro 2, 2012. Filed under: Java, Tips |

Esse é uma dica bem simples de como gerar hash md5 de uma String no Java:

import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class HashMd5 {
	public static void main(String[] args) {
		HashMd5 hashMd5 = new HashMd5();
		System.out.println(hashMd5.md5("Calcular hash deste texto"));
	}
	
	public String md5(String str) {
		 MessageDigest m = null;
		 String md5hash = null;
		 try {
		     m = MessageDigest.getInstance("MD5");
		 } catch (NoSuchAlgorithmException e) {
		          e.printStackTrace();
		 }        
		   
		 if(m != null) {
		       m.update(str.getBytes(),0,str.length());
		       BigInteger i = new BigInteger(1, m.digest());
		       md5hash = String.format("%1$032x", i);
		   }
		return md5hash;
	}
}

Resultado:

Hash Gerado: d24300b797dfab0df069cb6aaab442b4

Espero que possa ser útil em algum momento.

Ler Post Completo | Make a Comment ( None so far )

Java Tips: Preload de Imagens usando ImageIcon

Posted on dezembro 28, 2011. Filed under: Java, Tips |

Fazer preload de imagens no Java pode parecer um tanto complicado, porém é mais simples do que você imagina, ainda mais usando a classe ImageIcon. Para começar, vamos responder a pergunta: Em quais momentos você precisa que imagens sejam totalmente carregadas antes de continuar um determinado processo ? Tive essa situação no desenvolvimento de um Applet no qual deve carregar imagens que estão disponíveis na Internet.

O construtor da classe ImageIcon aceita um objeto do tipo URL como parâmetro. Você pode especificar uma URL onde esta localizada a imagem desejada. Internamente, na classe ImageIcon, é realizado o preload da imagem usando MediaTracker. Dessa forma é possível monitorar o status de loading desta imagem.

Segue abaixo exemplo de como usar o ImageIcon para carregar uma imagem em uma URL e somente continuar após a imagem ter sido carregada:

        try {
            ImageIcon image = new ImageIcon(new URL("http://www.exemplo.com.br/imagem.png"));
            
            //manter o loop enquanto a imagem estiver sendo carregada
            while(image.getImageLoadStatus() == MediaTracker.LOADING);
        
            //neste momento a imagem já foi totalmente carregada
            
        } catch (MalformedURLException ex) {
            ex.printStackTrace();
        }

Os possíveis status do MediaTracker são: LOADING (Carregando), COMPLETE (Totalmente carregada), ERRORED (Erro ao carregar), ABORTED (Cancelada).

Você pode obter a imagem em um objeto do tipo Image facilmente:

Image img = image.getImage();
Ler Post Completo | Make a Comment ( None so far )

Java Tips: Passando tipos primitivos por referência

Posted on dezembro 22, 2011. Filed under: Java, Tips |

Por padrão no Java os tipos primitivos (int,long,double,etc..) são passados por valor e não por referência. Portanto caso você altere o valor de um tipo primitivo dentro de um método, essa mudança não será visível fora da chamada do método. Por exemplo:

public void atualizaContador(int contador) {
		contador++;
}

int contador = 0;
atualizaContador(contador);

//contador agora = 0

Existem várias formas de contornar essa situação e obter o resultado desejado, como por exemplo, a criação de uma classe auxiliar… Porém uma maneira bem simples de resolver é criar um array com um único elemento. Arrays de tipos primitivos em java são passados como referência e não por valor:

public void atualizaContador(int[] contador) {
		contador[0]++;
}

int[] contador = new int[1];
contador[0] = 0;
atualizaContador(contador);

//contador[0] agora = 1
Ler Post Completo | Make a Comment ( None so far )

« Entradas Anteriores

Liked it here?
Why not try sites on the blogroll...

%d blogueiros gostam disto: