Fabio Brandão - Blog

PDB Extractor

Ainda em relação ao post anterior, tive que extrair o conteúdo de um arquivo PDB (um formato de arquivo usado nos Palm’s).

Encontrei a solução parcial neste post:http://www.neowin.net/forum/index.php?s=d21af43a292e783de98d0644c0824b70&showtopic=689476&pid=590047756&st=0&#entry590047756

A solução descrita não funcionou, mas após algumas alterações na solução, serviu para o que eu precisava:

/***
* T3_allfiles
* based upon T3_APR.java from Shadowmite's forum
*
* This file will extract a binary file from it's
* Palm PDB prison. Just drop this in the directory
* that contains the *.pdb files, and run it. It'll
* get them all. Well, mostly. See next.
*
* This file is NOT made to extract the rom image.
* Use Grack's RomTool for that.
*/

import java.io.*;

public class T3_allfiles {

public static void main(String[] args) throws Exception {
File directory = new File(”/home/fabio/Desktop/pdb/”);
String[] files = directory.list(new PDBfilter());

for (String individualFile : files) {
pdb2(”/home/fabio/Desktop/pdb/” + individualFile);
}
}

static void pdb2(String file) throws Exception {
System.out.println(file);
RandomAccessFile in = new RandomAccessFile(file, “r”);
in.skipBytes(76);
int numRec = in.readShort();
int[] toc = new int[numRec];
for (int i = 0; i < numRec; ++i) {
toc[i] = in.readInt();
in.readInt();
}
for (int i = 0; i < numRec; ++i) {
in.seek(toc[i]);
short fileNameSize = in.readShort();
byte[] fn = new byte[fileNameSize];
in.read(fn);

String fileName = new String(fn);
System.out.println(”\t” + fileName);

String[] directories = fileName.split(”\\/”);
String directory = “.”;
for (int j = 0; j < directories.length - 1; j++) {
directory += File.separator + directories[j];
}
new File(directory).mkdirs();

BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(fileName));

if (i < toc.length - 2) {
int bytesToRead = toc[i + 1] - toc[i] - fileNameSize - 2;
while (bytesToRead > 0) {
out.write(in.read());
bytesToRead–;
}
} else {
int b;
while ((b = in.read()) > -1) {
out.write(b);
}
}

out.close();
}
}
}

class PDBfilter implements FilenameFilter {
public boolean accept(File dir, String name) {
if (new File(dir, name).isDirectory()) {
return false;
}

name = name.toLowerCase();
return name.endsWith(”.pdb”);
}
}

Descompilando Java

Há algum tempo atrás, peguei um serviço pra fazer no qual o cliente não tinha o código fonte do sistema.

Após alguns dias procurando um descompilador java, achei este:

JD-Gui

Este descompilador é muito bom, devido à diversas features, como por exemplo, poder descompilar um jar inteiro, fazer links entre os arquivos descompilados, etc.

Selenium - Permission denied to get property Location.href

Hoje tive um problema no Selenium, no qual o mesmo não conseguia verificar a url do navegador, jogando uma exceção com a seguinte mensagem:

Permission denied to get property Location.href

Procurando no google, encontrei o seguinte blog:

http://www.woloszyn.org/2008/04/22/selenium-and-the-permission-denied-to-get-property-locationhref-problem/

Este blog mencionava que o problema era causado por um redirect enviado pelo response do servidor. A solução desse blog foi não utilizar o redirect.

Em outro site:

http://www.nabble.com/Permission-denied-to-get-property-Location.href-td8081383.html

Falava que só bastava utilizar o *chrome ou *iehta (no meu código estava sendo utilizado o *firefox). Após esta alteração, tudo voltou a funcionar normalmente.

Spring gerenciando as transações

Após duas longas semanas resolvi o problema que estava tendo com o Spring gerenciando as transações de banco de dados. O que acontecia é que nenhuma transação era aberta na classe marcada com a anotação “@Transactional”. Segue abaixo um exemplo de como utilizar o gerenciamento de transações do Spring:

package br.com.test;

public interface IService {

    int myServiceMethod(String myServiceParameter);

}

Segue abaixo a implementação, repare no uso da anotação “@Transactional” na classe (isto indica que a classe toda deve estar associada à um contexto transacional. É possível também marcar métodos:

package br.com.test;

import org.springframework.transaction.annotation.Transactional;

@Transactional
public class ServiceBean implements IService {

    public int myServiceMethod(String myServiceParameter) {
        return Integer.parseInt(myServiceParameter);
    }

}

Agora só falta configurar o “applicationContext.xml” do Spring:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:aop="http://www.springframework.org/schema/aop"
     xmlns:tx="http://www.springframework.org/schema/tx"
     xsi:schemaLocation="
     http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

  <bean id="myService" class="br.com.test.ServiceBean"/>

  <tx:annotation-driven transaction-manager="txManager"/>

  <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
  </bean>

  <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
    <property name="driverClassName" value="${jdbc.driverClassName}" />
    <property name="url" value="${jdbc.url}" />
    <property name="username" value="${jdbc.username}" />
    <property name="password" value="${jdbc.password}" />
  </bean>
</beans>

Repare no uso da tag “<tx:annotation-driven transaction-manager=”txManager”/>”. Esta tag ativa a configuração de transações baseada em anotações.

Até aí é muito simples utilizar o gerenciamento de transações do Spring. O problema que tive foi o seguinte: meu serviço possuía uma interface, e esta interface estava sendo implementada por uma classe abstrata. Essa classe abstrata definia o método que eu queria que fosse transacional. Depois eu criei uma terceira classe que extendia essa classe abstrata. Coloquei a anotação “@Transactional” na classe concreta, e o Spring não gerenciava as transações no método definido na classe abstrata. Para resolver o problema só foi necessário colocar a anotação da classe abstrata.