André L. S. » Java

A importância de File.separator e File.pathSeparator

André — Wed, 24 Aug 2011 16:35:07 +0000

Quase todos os programadores Java conhecem os métodos citados no título, mas muito poucos se preocupam em utiliza-los.

Estes dois métodos servem para que o programador não precise “adivinhar” qual é o separador de arquivos e qual é o separador de caminhos em cada sistema operacional.

No Linux/Unix, os métodos File.separator e File.pathSeparator retornam “/” e “.” respectivamente, enquanto que, no Windows, estes mesmos métodos retornam “\” (ou “\\” – escape) e “;”.

Passei por um caso recente, onde o código abaixo lançava a exception FileNotFoundException no Linux, mas funcionava perfeitamente no Windows:

String caminhoAp = ctx.getRealPath();
String caminhoArq = caminhoAp + "\\" + "WEB-INF/classes/pacotes/da/minha/aplicacao/";

File arquivo = new File(caminhoArq, "relatorio.pdf");
OutputStream out = new FileOutputStream(arquivo);
...

Então passou a funcionar nos dois sistemas operacionais após substituir “\\” por File.separator na linha 2, desta forma:

String caminhoAp = ctx.getRealPath();
String caminhoArq = caminhoAp + File.separator + "WEB-INF/classes/pacotes/da/minha/aplicacao/";

File arquivo = new File(caminhoArq, "relatorio.pdf");
OutputStream out = new FileOutputStream(arquivo);
...

A utilização destes métodos, além de ser uma boa prática, é muito útil quando se tem a mesma versão de um sistema feito em Java rodando de diferentes sistemas operacionais.

Como recuperar e escrever campos CLOB

André — Fri, 13 May 2011 17:01:25 +0000

O Character Large Object (ou CLOB), como o próprio nome já diz, é um tipo de campo muito comum em Bancos de Dados usado para armazenar textos com uma quantidade enorme de caracteres.

No MySQL, por exemplo, o tipo CLOB está descrito como MEMO, mas a função é a mesma.

Estes dias precisei recuperar um valor de um campo CLOB que era retornado por um SELECT, como nunca tinha utilizado este campo no Java, resolvi escrever este pequeno tutorial como um memorando e, também, ajudar a quem precisar.

Escrevendo valores em campo CLOB

O método do PreparedStatement utilizado para a gravação de um CLOB é o setAsciiStream, passando a posição do campo CLOB, o InputStream dos dados e o ponto final de leitura do InputStream.

ps.setAsciiStream(posicaoClob, inputStream, tamanhoDoTexto);

Exemplo funcional:

String sql = "INSERT INTO TESTE (texto) VALUES(?)";
		try{
			String txt = leArquivoTxt();
			ByteArrayInputStream bais = new ByteArrayInputStream(txt.getBytes());

			PreparedStatement ps = conexao.prepareStatement(sql);
			//Campo CLOB é a '?' que está na posição 1 do INSERT
			ps.setAsciiStream(1, bais, txt.length());

			ps.execute();

			ps.close();
		}catch (Exception e) {
			e.printStackTrace();
		}

Recuperando valor de um campo CLOB

Como executamos um SELECT, será necessário capturar o ResultSet , iterar as linhas e chamar o método para a recuperação de um CLOB é o getClob, passando a posição em que o campo se encontra na query ou, simplesmente, o nome da coluna.

rs.getClob("xml");

Exemplo funcional:

String sql = "SELECT xml FROM TESTE";
		try{
			PreparedStatement ps = conexao.prepareStatement(sql);
			ResultSet rs = ps.executeQuery();

			while(rs.next()){
				Clob clob = rs.getClob("xml");
				BufferedReader reader = new BufferedReader(clob.getCharacterStream());
				StringBuffer strBuf = new StringBuffer();

				String linha = null;
				while((linha = reader.readLine()) != null){
					strBuf.append(linha);
//Character.LINE_SEPARATOR insere a quebra de linha
					strBuf.append((char)Character.LINE_SEPARATOR);
				}

				System.out.println("=========== CLOB ===========");
				System.out.println(strBuf.toString());
			}

			rs.close();
			ps.close();
		}catch (Exception e) {
			e.printStackTrace();
		}

É isso aí. Simples, fácil e indolor.

Caso queiram, podem baixar a aplicação de exemplo aqui

Para recuperar um campo BLOB veja este tópico.

Configurando acesso à internet via proxy em aplicações Java

André — Wed, 24 Mar 2010 01:35:42 +0000

Hoje tive um problema no meu trabalho onde um client, que roda via prompt de comando (Prompt do DOS), não conseguia acessar o servidor hospedado na internet, isso porque a empresa onde trabalho utiliza proxy.

Depois de algumas tentativas acabei achando duas soluções para resolver o problema de acesso: a primeira foi passar como parâmetros Java as configurações do proxy.

$ java -Dhttp.proxyHost=serv -Dhttp.proxyPort=porta -Dhttp.proxyUser=usu -Dhttp.proxyPassword=senha ClasseJava

-Dhttp.proxyHost = IP ou nome do servidor proxy
-Dhttp.proxyPort = Porta do proxy
-Dhttp.proxyUser = Usuário
-Dhttp.proxyPassword = Senha

Desta forma a classe ClasseJava terá acesso à internet através do proxy.

A outra forma foi inserir as configurações na própria classe:

public static void main(String[] args){
...
System.getProperties().put("proxySet", "true");
System.getProperties().put("http.proxyHost", "serv");
System.getProperties().put("http.proxyPort", "porta");
System.getProperties().put("http.proxyUser", "usuario");
System.getProperties().put("http.proxyPassword", "senha");
...
}

proxySet = Define se passará ou não por um servidor proxy
http.proxyHost = IP ou nome do servidor proxy
http.proxyPortt = Porta do proxy
http.proxyUse = Usuário
http.proxyPassword = Senha

Usando um destes recursos você poderá configurar sua aplicação para acessar à internet através de um proxy.

Espero ter ajudado. Até +!

Criando janelas transparentes e com formas usando Java Swing/AWT

André — Tue, 16 Mar 2010 22:40:50 +0000

O AWT nos oferece uma gama de possibilidades quando falamos sobre manipulação de janelas. Hoje falarei sobre duas destas possibilidades com a classe AWTUtilities.

Deixando a janela transparente

Para deixar uma Window (JFrame, JDialog e etc) transparente, você deve usar o método AWTUtilities.setWindowOpacity. Este método recebe como parâmetro a janela que deve ser alterada e o grau de transparência, que varia entre 0 (zero) e 1, sendo 0 (zero) invisível e 1 totalmente visível.

JFrame  window = new JFrame("Minha janela");

//70% de transparência
AWTUtilities.setWindowOpacity(window, .7f);
window.setSize(800,600);
window.setVisible(true);

O resultado será:

Alterando a forma da janela

Para alterar a forma da janela você deve usar o método AWTUtilities.setWindowShape. Este método recebe como parâmetro a janela que deve ser alterada e a forma (java.awt.Shape) que a janela deverá assumir.

A forma mais eficiente de usar este método é através do componentResized(), pois você poderá recalcular o tamanho da janela para não deforma-la ou não perder os componentes de vista.

Aqui deixaremos nossa janela com a forma de um triângulo com 70% de transparência.

final JFrame  window = new JFrame("Minha janela");

try {
	//Adicionando o ComponentListener responsável pelo componentResized
	window.addComponentListener(new ComponentAdapter(){
		@Override
		//implementando o método componentResized
		public void componentResized(ComponentEvent e) {
			int[] x = {0,400,800}; //Pontos X do polígono
			int[] y = {600,0,600}; //Pontos Y do polígono

			//Criaremos um triângulo de 800 x 600
			Shape shape = new Polygon(x, y, 3);

			AWTUtilities.setWindowShape(window, shape);

			//com transparência de 70%
			AWTUtilities.setWindowOpacity(window, 0.7f);
		}
	});
} catch (SecurityException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
} catch (IllegalArgumentException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
}

window.setUndecorated(true); //removendo barra de título
window.setSize(800,600);
window.setVisible(true);

Repare que invoquei o método setUndecorated( ) passando o valor true, este método é responsável por ocultar a barra de título (aquele com o ícone e os botões de maximizar, minimizar e fechar) que, se estiver visível, o método AWTUtilities.setWindowShape( ) não surtirá efeito.

O resultado:

Espero que tenham gostado e até a próxima!

//Pontos X do polígono

Inserindo arquivos em campos BLOB de uma base de dados

André — Mon, 22 Feb 2010 16:39:03 +0000

Para inserir um arquivo, seja ele de qualquer formato, é necessário utilizar o método setBinaryStream implementado pelo PreparedStatement.

PreparedStatemente.setBinaryStream(int índice, Inputstream is, int tamanho);

Para o exemplo definimos uma tabela chamada arquivo que contém um campo BLOB chamado ARQ.

//Conexão normal, como qualquer JDBC
Class.forName("oracle.jdbc.driver.OracleDriver");
Connection conn = DriverManager.getConnection("jdbc:oracle:thin:@::","","");

//Acessando o arquivo a ser enviado e recuperando um InputStream
File arquivo = new File("");
FileInputStream fis = new FileInputStream(arquivo);

//Preparando a chamada normalmente
PreparedStatement ps = conn.prepareStatement("INSERT INTO ARQUIVO (arq) VALUES(?)");

//Informando o inputstream e o tamanho do arquivo a ser enviado
ps.setBinaryStream(1, fis, (int)arquivo.length());

ps.execute();

ps.close();
conn.close();

No meu teste utilizei a base de dados Oracle 8i. Como não tenho à disposição uma base MySQL/PostgreSQL/MS SQL Server, deixo vocês encarregados de testar e me enviar os resultados, OK?

[]‘s e até a próxima!

Recuperando cursor de uma procedure do Oracle no Java

André — Mon, 18 Jan 2010 01:07:32 +0000

Percebi que muitas pessoas acabam chegando aqui pesquisando uma forma de recuperar cursores através de procedures do Oracle, para estas pessoas eu coloco à disposição uma maneira de fazê-lo.

Para que o cursor possa ser retornado é preciso declara-lo como REF CURSOR no spec da Package.

  --Criando o tipo REF CURSOR que será o cursor
  type g_cursor is ref cursor;

Em ambos, spec e body, você precisa declarar uma variável out do tipo do REF CURSOR mencionado acima.

  procedure PRO_RETORNA_LISTA_CARROS(
    i_id     in     tbl_car.car_id%type,
    o_cursor in out g_cursor);

Para devolver o cursor com os resultados (caso haja), é necessário abri-lo no body da procedure, desta forma:

open o_cursor for
          select car_id, company, model, color, hp, price
          from tbl_car
          where car_id = i_id;

A Package completa ficará assim:

create or replace package PAC_CURSOR is
  --Criando o tipo REF CURSOR que será o cursor
  type g_cursor is ref cursor;

  --Procedure que retornará o cursor
  procedure PRO_RETORNA_LISTA_CARROS(
    i_id     in     tbl_car.car_id%type,
    o_cursor in out g_cursor); -- Nosso cursor

end PAC_CURSOR;
/

create or replace package body PAC_CURSOR is
  procedure PRO_RETORNA_LISTA_CARROS(
    i_id     in     tbl_car.car_id%type,
    o_cursor in out g_cursor) is

       begin
        --Abrindo o cursor para retornar os valores
        open o_cursor for
          select car_id, company, model, color, hp, price
          from tbl_car
          where car_id = i_id;

  end PRO_RETORNA_LISTA_CARROS;

end PAC_CURSOR;

Temos o lado do Oracle pronto, agora precisamos tratar a chamada no Java.

Como o cursor está sendo retornado por uma procedure, usaremos um java.sql.CallableStatement.

CallableStatement cs = conn.prepareCall("{call PAC_CURSOR.PRO_RETORNA_LISTA_CARROS(?,?)}");

O registerOutParameter receberá o tipo oracle.jdbc.OracleTypes.CURSOR e retornará um java.sql.ResultSet. Iteraremos o ResultSet do mesmo modo que iteramos um Iterator.
Cada coluna retornada pelo SELECT será representado como um mapa, usando o getter correpondente. Por exemplo, chamaremos o método getString() quando retornar um varchar, getDate() quando retornar um date e etc.

O código completo fica assim:

//Chamando o procedure
CallableStatement cs = conn.prepareCall("{call PAC_CURSOR.PRO_RETORNA_LISTA_CARROS(?,?)}");

//Definindo o tipo do retorno, no caso o cursor
cs.registerOutParameter("o_cursor", OracleTypes.CURSOR);
cs.setLong("i_id", id);

cs.execute();//Executando a chamada

//Recuperando o cursor como um Resultset
ResultSet rs = (ResultSet)cs.getObject("o_cursor");

//Iterando as linhas retornadas
while(rs.next()){
	//Obtendo o valor das colunas
	System.out.println("ID: " + rs.getLong("car_id"));
	System.out.println("Marca: " + rs.getString("company"));
	System.out.println("Modelo: " + rs.getString("model"));
	System.out.println("Cor: " + rs.getString("color"));
	System.out.println("HP: " + rs.getString("hp"));
	System.out.println("Preco: " + rs.getFloat("price"));
}

No final você conseguirá obter qualquer valor retornado em um SELECT.

Até a próxima!

Gerando ‘EXE’ para iniciar suas aplicações Java

André — Wed, 28 Oct 2009 01:25:19 +0000

Percebi que muitos desenvolvedores precisam, ou já precisaram, distribuir suas aplicações Java de forma que os usuários de Windows pudessem iniciá-las naturalmente, sem a necessidade de chamar o comando java -jar ou executar um arquivo .BAT.

Eu, que também já passei por isso, encontrei um solução fácil e com muitos recursos: JSmooth.

Este programinha possibilita que você “transforme” seu JAR em um executável (EXE), mas claro, ainda sim você precisará ter o JVM instalado no micro que rodará o executável.

Aqui só destacarei as configurações que considero relevantes, então vamos ao que interessa!

Baixe o JSmooth em http://sourceforge.net/projects/jsmooth/files/;

Após instalá-lo (ou descompactá-lo, depende do arquivo que você baixou) execute-o;

No menu lateral, clique em “Skeleton“;

No “Skeleton Selection” você informa como a aplicação será executada, aqui selecionaremos Window Wrapper.

No “Skeleton Properties” você define uma mensagem caso o usuário não tenha o JVM instalador (Message) e onde ele poderá baixá-lo (URL).

“Launch java app in the exe process” indica se o JAR será executado no mesmo processo do EXE, aparecendo somente o executável no Gerenciador de Tarefas do Windows, caso contrário também será o processo javaw.exe.

“Single Instance” define se você ser aberto mais de uma instância.

“Debug Console” executa o EXE em uma janela do prompt de comando, exibindo os possíveis Stacktraces gerados pela aplicação.

Agora clique em “Executable”

Em “Executable Settings” você informa onde o EXE será gerado (“Executable Binary“), o ícone do EXE (“Executable Icon“) e qual será o diretório de execução da aplicação.

Clique em “Application”

Primeiro, clique no ícone e selecione o JAR que contém a classe principal (que contém o método main).

Em seguida, selecione a classe no campo “Main Class” clicando no botão .

O campo “Application arguments” você passa os parâmetros necessário para a sua classe.

“Embedded JAR” possibilita que você integre seu JAR no EXE, ou seja, não será necessário ter os dois arquivos, pois o EXE descompactará o JAR a cada execução.

Agora, clique em “JVM Selection“.

Aqui você pode definir qual versão, mínima (“Minimum JVM Version“) e máxima (“Maximum JVM Version“), da virtual machine rodará sua aplicação.

O”JVM Search Sequence” indica a ordem de busca do arquivo javaw.exe, neste caso ele procurará primeiro no registro, depois no diretório informado na variável de ambiente “JAVA_HOME” e assim por diante.

E então clique em “JVM Configuration”

Aqui você informa a quantidade máxima de memória que sua aplicação poderá usar (“Maximum Memory“), quanta memória será alocada para sua aplicação assim que ela iniciar (“Initial Memory Allocation“) e os argumentos que será passado à JVM para sua aplicação.

Até este ponto você somente configurou o JSmooth, mas ainda não temos o EXE. Para isso, clique no botão , caso você ainda não tenha salvo o projeto será aberta uma janela para escolher o local de salvamento do arquivo. Feito isso, o EXE será gerado no diretório indicado no campo “Executable Binary” da tela “Executable“.

Agora é só dar um duplo clique no arquivo EXE e aplicação iniciará!

Para mais informações acessem http://jsmooth.sourceforge.net/

Espero que tenham gostado, comentem à vontade!

Até mais!

Recuperando coleção de objetos de uma procedure Oracle

André — Mon, 21 Sep 2009 19:06:53 +0000

Como prometido há muito tempo atrás (e bota tempo nisso) no tópico “Passando Objetos Java para uma Procedure do Oracle“, mostrarei como recuperar objetos Java contendo uma coleção de outro objetos através de uma procedure do Oracle. Para quem não leu, é altamente recomendado ler o post anterior.

Para este tutorial, precisamos incluir a tabela TBL_CLASS e adicionar sua primary key como foreign key na TBL_USER.

--num class será a PK e o desc_class será a descrição
create table TBL_CLASS (num_class number, desc_class varchar(100));
alter table TBL_CLASS add primary key(num_class);

alter table TBL_USER add num_class number;
alter table TBL_USER add constraint FK_CLASS foreign key(num_class) references tbl_class(num_class);

Agora precisamos incluir os novos tipos:

create or replace type class_type as object (num_class number, desc_class varchar2(100), users arr_users);
/
create or replace type arr_class as table of class_type;
/

O tipo class_type será o objeto. Repare que na sua assinatura incluímos o tipo arr_users, que será nossa coleção de user_type (vide post anterior), o tipo arr_class será uma coleção de class_type.

Agora incluiremos a procedure responsável por retornar nossa coleção de class_type.

procedure pro_select_class(clas in class_type, class_return in out arr_class)is
  class_ref_cur ref_cur;
  --Coleção de classes
  classes arr_class := arr_class();

  begin
    open class_ref_cur for
      select cast(
                multiset(
                  select num_class,
                         desc_class,
                         (select cast(
                                  multiset(
                                    select user_name,
                                           height,
                                           b_date
                                    from tbl_user
                                    --Fazendo o JOIN com a TBL_USER
                                    where tbl_user.num_class = tbl_class.num_class
                                  ) as arr_users)
                          from dual) users
                  from tbl_class
                  --Usando o atributo num_class do parâmetro de entrada
                  where num_class = clas.num_class) as arr_class
      ) classes
    from dual;

    --incluindo ao retorno no array
    fetch class_ref_cur into classes;
    --passando o array para a variável out
    class_return := classes;
end pro_select_class;

Repare que a procedure recebe o tipo class_type como parâmetro in e retorna o tipo arr_class.

Separando trecho responsável por resgatar e montar nossos objetos teremos:

--Montará a coleção de retorno
select cast(
        multiset(

          --Retornará os objetos class_type e seus atributos
          select num_class,
                 desc_class,

                 --Populará a coleção com user_type
                 (select cast(
                          multiset(
                            select user_name,
                                   height,
                                   b_date
                            from tbl_user
                            where tbl_user.num_class = tbl_class.num_class
                          ) as arr_users)

                  from dual) users

          from tbl_class
          where num_class = clas.num_class) as arr_class
) classes
from dual;

Os objetos de banco estão prontos, agora para o Java!

Criaremos o objeto que será interpretado pelo Oracle. Vamos chamá-lo de TypeClass:

public class TypeClass implements SQLData{
	public static final String ORACLE_OBJECT_NAME = "CLASS_TYPE"; //Nome do tipo no Oracle
	public static final String ORACLE_CLASS_ARRAY_NAME = "ARR_CLASS"; //Nome do array no Oracle

        //campos criados na tabela TBL_CLASS
	private Long number;
	private String desc;
	private Array users; //Esta será a coleção de user_type (ou TypeUser no Java)

	public String getSQLTypeName() throws SQLException {
		return ORACLE_OBJECT_NAME;
	}

	public void readSQL(SQLInput stream, String typeName) throws SQLException {
		setNumber(stream.readLong());
		setDesc(stream.readString());
		setUsers(stream.readArray());//Usado pelo JDBC driver para ler a coleção
	}

	public void writeSQL(SQLOutput stream) throws SQLException {
		stream.writeLong(getNumber());
		stream.writeString(getDesc());
		stream.writeArray(getUsers());//Usado pelo JDBC driver para armazenar a coleção
	}
	//Getters e setters omitidos
}

Precisamos mapear os dois tipos já que ambos serão interpretados na requisição, desta forma:

Map> typeMaps = connection.getTypeMap();
typeMaps.put(TypeUser.ORACLE_OBJECT_NAME, TypeUser.class);
typeMaps.put(TypeClass.ORACLE_OBJECT_NAME, TypeClass.class);

Também precisaremos mapear os dois arrays:

typeMaps.put(TypeClass.ORACLE_CLASS_ARRAY_NAME, TypeClass[].class);//retornado pela procedure
typeMaps.put(TypeUser.ORACLE_USER_ARRAY_NAME, TypeUser[].class);//retornado pela coleção de class_type

Para a requisição faremos:

cs = conn.prepareCall("{call PAC_BEAN.PRO_SELECT_CLASS(?,?)}");
//registrando o tipo de saída, que será um array de TypeClass
cs.registerOutParameter("class_return", OracleTypes.ARRAY, TypeClass.ORACLE_CLASS_ARRAY_NAME);

//passando o objeto de parâmetros da query
cs.setObject("clas", classQry);

cs.execute();
//recuperando e iterando o array de TypeClass
Object[] array = (Object[])cs.getArray("class_return").getArray();

for(Object obj : array){
	TypeClass objClass = ((TypeClass)obj);

	System.out.println("Description: "+objClass.getDesc());

        //Aqui pegamos a coleção (ou array) de user_type(TypeUser) retornada pela query.
	Object[] userArray = (Object[])objClass.getUsers().getArray();
	for(Object user : userArray){
		System.out.println("\tName: " + ((TypeUser)user).getName());
		System.out.println("\tHeight: " + ((TypeUser)user).getHeight());
		System.out.println("\tBirth: " + sdf.format(((TypeUser)user).getBirth())+ "\r\n");
	}
}

O final você terá um TypeClass que contém um java.sql.Array de TypeUser no atributo getUsers().

E aqui cumpro minha promessa. Baixe o código fonte com o exemplo contendo este e o post anterior aqui.

Até a próxima!

Tirando Screen Shots com Java

André — Wed, 16 Sep 2009 22:35:57 +0000

Aqui mostrarei como fazer uma classe para tirar Screen shots .

Estava pensando com quão complexo seria fazer uma classe que tirasse screen shots do compulador local e o armazenasse em um arquivo. Perguntando ao tio “G” descobri a classe Robot, que possui o método createScreenCapture.

Agora mostrarei como implementar esta funcionalidade:

Robot robot = new Robot();
//Definindo o retângulo que será a área de captura da tela que, neste caso, será a tela inteira.
Rectangle rect = new Rectangle(Toolkit.getDefaultToolkit().getScreenSize());

BufferedImage img = robot.createScreenCapture(rect);

Aqui definimos a área de captura e obtivemos um BufferedImage, que já é nossa imagem. Agora é só persisti-la no disco.

//Capturando o ImageWriter e ImageWriterParam
ImageWriter writer = ImageIO.getImageWritersByFormatName("jpeg").next();
ImageWriteParam iwp = writer.getDefaultWriteParam();

//Definindo o modo de compressão e a qualidade
iwp.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
iwp.setCompressionQuality(1);

//Persistindo a imagem
writer.setOutput(new FileImageOutputStream(arquivo));

IIOImage iioimage = new IIOImage(img, null, null);

writer.write(null, iioimage, iwp);
writer.dispose();

Aqui capturamos o ImageWriter e ImageWriterParam para configurar o método de compressão e a qualidade da imagem.

Na linha 07 definimos a qualidade como 1, onde o valor varia de 0 (zero), maior compressão e menor qualidade, até 1 (um), menor compressão e maior qualidade. Em seguida persistimos o arquivo no HD.

Pronto! Simples, não?!.

Faça o download do exemplo aqui.

Até a próxima!

Neste caso será a tela inteira.

Limitando número máximo de caracteres em um JTextField

André — Thu, 27 Aug 2009 16:28:34 +0000

A implementação padrão do JTextField não permite definir um limite para inserção de caracteres. Para habilitar este recurso é necessário implementar um Document, onde será necessário sobrescrever o método insertString.

public class MaxLengthTextDocument extends PlainDocument {
	//Armazena o número máximo de caracteres para o texto.
	private int maxChars;

	@Override
	public void insertString(int offs, String str, AttributeSet a)
			throws BadLocationException {
		if(str != null && (getLength() + str.length() < maxChars)){
            		super.insertString(offs, str, a);
        	}
	}

	//getter e setter omitidos
}

Aqui definimos a classe MaxLengthTextDocument estendendo a PlainDocument. No atributo insertString inserimos uma regra onde só será inserido valor se comprimento não ultrapassar o valor máximo.

Depois é só inserir a implementação no JTextField, desta forma:

	...
	MaxLengthTextDocument maxLength = new MaxLengthTextDocument();
	maxLength.setMaxChars(50);//Limitamos para 50 caracteres

	jTextField.setDocument(maxLength);
	...

E voilá!

Até mais!

JLabel com preenchimento (Padding)

André — Fri, 21 Aug 2009 21:29:45 +0000

Para adicionar preenchimento (padding) à um JLabel podemos usar as próprias bordas. Colocamos um EmptyBorder com o espaçamento que precisamos. Desta forma:

...
JLabel jLabel = new JLabel("Meu JLabel");
//Borda usada para o preenchimento
Border paddingBorder = BorderFactory.createEmptyBorder(10,10,10,10);

jLabel.setBorder(BorderFactory.createCompoundBorder(border,paddingBorder));
...

Neste caso colocamos um espaçamento de 10 pixels no topo, à esquerda, à direita e em baixo do JLabel respectivamente.

Se ainda quiser colocar uma borda envolta do JLabel, pode-se usar uma CompoundBorder, inserindo a borda e o preenchimento. Desta forma:

...
JLabel jLabel = new JLabel("Meu JLabel");
//Borda usada para o preenchimento
Border paddingBorder = BorderFactory.createEmptyBorder(10,10,10,10);
//Borda que ficará envolta do JLabel
Border border = BorderFactory.createLineBorder(Color.BLUE);

jLabel.setBorder(BorderFactory.createCompoundBorder(border,paddingBorder));
...

Baixe o código fonte desta dica aqui.

Tutorial iBatis, aprendendo o básico

André — Sat, 04 Jul 2009 15:53:37 +0000

Geralmente quando se fala sobre frameworks de persistência logo vem à cabeça Hibernate/JPA. Há pouco tempo fui apresentado ao iBatis, um framework que eu, particularmente, acho muito fácil de instalar, configurar e usar. Você pode baixa-lo através do site de sua mantenedora, a Apache, clicando aqui.

Neste tutorial usarei a versão 2.3.4 build 726.

Configurando o iBatis

Ao contrário dos demais frameworks, para configurar o iBatis você só precisa de um arquivo XML de configuração, chamado SqlMapConfig.

As principais seções do xml são:

Este código é opcional e serve para indicar o arquivo properties com as variável de configuração que serão usada no XML.

Indica o Bean utilizado e qual será seu aliás. Você pode configurar várias linhas, tudo depende da complexidade e necessidade da sua modelagem.
No nosso exemplo, usaremos o bean Car abaixo:

public class Car {
	private Long carId;
	private String company;
	private String model;
	private String color;
	private Integer	hp;
	private Float price;

	//Setters e getters omitidos
}

Parâmetros usados na conexão com o banco. As variáveis ${driver}, ${url}, ${username} e ${password} estão definidas no arquivo .properties indicado na seção properties. Se você preferir, também pode colocar os valores diretamente nos campos, sem precisar defini-los em outro local.

Veja como será arquivo completo:

O properties tem o seguinte conteúdo:

driver=oracle.jdbc.OracleDriver
url=jdbc:oracle:thin:@::
username=
password=

Em seguida devemos configurar nosso SqlMap. Este XML conterá as querys utilizadas na aplicação e deverá ter o nome do descrito na seçao sqlMap do SqlMapConfig, no nosso caso será CarSqlMap.xml.

No nosso exemplo apenas veremos a utilização das tags select, insert, update e delete.

Executa o select podendo retornar uma única linha ou uma coleção, o tipo retornado é o mesmo especificado no atributo resultClass, o parameterClass é o tipo passado para executar a query e o id é a identificação para chamada da query.

Usaremos o SqlMap abaixo:






    

    
        INSERT INTO TBL_CAR (CAR_ID, COMPANY, MODEL, COLOR, HP, PRICE)
        VALUES (#carId#, #company#, #model#, #color#, #hp#, #price#)
    

    
        DELETE FROM TBL_CAR WHERE CAR_ID = #var#
    

    
        UPDATE TBL_CAR
          SET COMPANY = #company#,
              MODEL = #model#,
              COLOR = #color#,
              HP = #hp#,
              PRICE = #price#
        WHERE CAR_ID = #carId#

Agora que já configuramos o acesso ao banco de dados e o mapeamento dos objetos, vamos implementar a classe singleton que usaremos como SqlMapClient, aqui nós a chamaremos de OracleMapConfig.

package tuto.ibatis.connection;

import java.io.Reader;

import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;

public class OracleMapConfig {
	private static final SqlMapClient sqlMapClient;

	static{
		try{
			//Definindo o caminho para o SqlMapConfig e criando o reader
			String res = "tuto/ibatis/config/SqlMapConfig.xml";
			Reader reader = Resources.getResourceAsReader(res);

			//Recuperando o client para o SqlMap
			sqlMapClient = SqlMapClientBuilder.buildSqlMapClient(reader);
		} catch(Exception e){
			e.printStackTrace();
			throw new RuntimeException(e);
		}
	}

	//Método usado para recuperar o client
	public static SqlMapClient getSqlMapClient(){
		return sqlMapClient;
	}
}

O client é responsável por executar as querys configuradas no SqlMap e nos fornecer os resultados.

Executando Querys e tratando retornos

Para chamar uma das querys é muito simples, apenas chame o cliente e o método correspondente de cada uma.

O select pode ser chamado da seguinte forma:

OracleMapConfig.getSqlMapClient().queryForObject("", );

O iddeve ser o id correspondente no SqlMap

O código acima tráz apenas uma linha retornada pela query, para trazer todas apenas troque o método para o queryForList, desta forma:

OracleMapConfig.getSqlMapClient().queryForList("", );

Assim, será retornado uma Collection contendo os objetos.

Vamos aos exemplos:
Select

try{
	Car car = (Car)OracleMapConfig.getSqlMapClient().queryForObject("getCars",
		new Long(readKeyboard()));

	System.out.println("Marca: "+car.getCompany());
	System.out.println("Modelo: "+car.getModel());
	System.out.println("Cor: "+car.getColor());
	System.out.println("HP: "+car.getHp());
	System.out.println("Preço: "+car.getPrice());
}catch (Exception e) {
	e.printStackTrace();
}

O id “getCars” é o que definimos nos atributos do select do SqlMap, passando um Long e recuperando o tipo Car, ambos também definidos na linha