I sometimes need to use the Criteria in JPA, I don't know why, but the create query method not accept order with asc and desc in the same query, the Criteria support it, but damn, it's very hard, I don't know who think this code
ParameterExpression age = qb.parameter(Integer.class);
Predicate condition = qb.gt(p.get(Person_.age), age);
c.where(condition);
TypedQuery q = em.createQuery(c);
List result = q.setParameter(age, 20).getResultList();
is better than this one
String jpql = "select p from Person p where p.age > :age";
Query query = em.createQuery(jpql).setParameter("age", 20);
List result = query.getResultList();
I don't need to map my class into another object called metamodel, one change in a model results into two changes, the model and the metamodel. Go to hell with de metamodel, we don't want, and don't need it, I write my queries using JPQL and don't want to use the Criteria API. Why they don't use the hibernate style? The code below isn't better?
Quem nunca precisou usar alguma formula matemática em Java, para efetuar alguma operação?
Existem alguns casos que o usuário quer definir a formula do calculo. Muitas vezes isso é uma comodidade para ele, e um PARTO para os desenvolvedores, algumas metodologias ou bibliotecas resolvem o problema, porém você tem que implementar algo, sempre tem algum ajuste. Precisei usar o Metodo Price em um calculo financeiro, a formula não é complexa, mas como toda a formula matemática, deve se ter cuidado com os parênteses. Eu pensei em fazer algo mais braçal, mas como um bom preguiçoso, resolvi gastar um certo tempo pesquisando algumas maneiras de fazer isso, eis que me surge uma luz no fim do túnel, o Bean Scripting Framework. Linguagens de script são mais flexíveis nesse aspecto que em Java, muitas vezes temos que fazer em alguns casos contornos maiores, como usamos Java 6 para desenvolver, que tem suporte ao ScriptEngine, tudo flui mais fácil, se você usa alguma versão mais antiga, por favor faça um upgrade urgente, quem está perdendo é você.
PS: As bibliotecas são referenciadas via maven, se for usar ANT ou qualquer outra coisa, tem que procurar no Google.
vamos precisar de duas simples bibliotecas o projeto o Bean Scripting Framework (BSF -> bsf:bsf) e o groovy (org.codehaus.groovy:groovy) (você pode usar Jython, JRuby, e qualquer outra coisa que queira), vou usar uma formula simples inventada por mim: x ** 2 + 10
auhsduhahsduas, chega a ser ridículo, mas depois muda isso ai pra testar (o operador ** no groovy representa potenciação)
Olha a trabalheira:
String formula = "x ** 2 + 10";
BSFManager manager = new BSFManager();
manager.declareBean("x", "10", Integer.class);
Double result = (Double) manager.eval("groovy", "myScript.groovy", 0, 0, formula);
Eu fiz um cast pra Double, mas o retorno é um object, pode retornar qualquer coisa.
Mas fácil que isso só dois disso heheh.
Muito comum essa dúvida, porém nem tão pratica :D.
Para ferramentas baseadas em plugins o ideal é usar OSGi mesmo, que funciona muito bem.
Mas existem casos em que precisamos de um determinado jar que não está no classpath da aplicação seja adicionado de acordo com as vontades do usuário.
Existe um metodo bem simples, usando reflection que permite que isso seja feito.
o metodo toURL dentro da classe file está deprecated, então usamos o toURI e depois toURL, lembrando que para criar o arquivo é necessário o caminho completo do Jar.
usando reflection pegamos o metodo protegido "addURL" dentro do URLClassLoader, e simplesmente o invocamos :D
Não sei se muita gente usa isso, mas eu uso, um client swing, para um modulo EJB, recentemente, saiu a versão V3 do glassfish, e lá fui eu tentar comunicar com o container EJB, até a versão v2 as bibliotecas necessarias eram o JavaEE 5, appserv-rt, appserv-deployment, appserv-admin e o appserver-ext, isso devia tar entorno de uns 20MB de bibliotecas.
Seguindo ao FAQ do Glassfish eu devia adicionar somente o GF-CLIENT no classpath da applicação, um jarzinho de alguns KB, e adivinha, não funcinou, depois de uma extensiva busca não encontrei solução e cheguei a conclusão que, NÃO ACREDITE NO FAQ DO CLASSFISH. Além desse tal de gf-client, eles aconselham vc a usar o construtor sem argumentos da classe InitialContext, se vc quiser conectar SOMENTE EM LOCALHOST use o construtor sem argumetos.
Criei um projeto, adicionei todos os jars do GLASSFISHV3_HOME/glassfish/modules, a conexão funcionou 100%, agora era ver quais jars iriam manter minha conexão ativa, e fui removendo 1 a 1 os jars e testando, chegando finalmente a 6MB de jars (diminui bastante comparado com as versões anteriores), que devem estar no seu classpath, listados abaixo
auto-depends
common-util
config-api
config
config-types
dol
deployment-common
ejb.security
ejb-container
glassfish-naming
glassfish-api
glassfish-corba-orb
glassfish-corba-omgapi
glassfish-corba-orbgeneric
glassfish-corba-codegen
glassfish-corba-newtimer
glassfish-corba-csiv2-idl
glassfish-corba-asm
gmbal
hk2-core
internal-api
javax.resource
java.ejb
kernel
management-api
orb-connector
orb-iiop
security
tiger-types-osgi
E nenhum dos gf-QUALQUER_COISA é necessario, essa aplicação está em produção desse modo. Alguns desses jars são encontrados em repositorios maven como tiger-types-osgi, eu optei por adicionar a maioria no repositorio local e esses mesmo para não ter problema.
Num sei vcs, mas tivemos diversos problemas com as versões do ireport pós 3.0, EJBQL Connection não funcionava, e ninguem sabia como resolver, cheguei a cirar 2 threads no Forum do JasperForge e ambas sem resposta, no final, ficamos com o IReport 3.0, a versão funcionava bem, apesar da interface ser meio bugada (algumas janelas eram fechadas e sumiam misteriosamente).
Sempre gostamos de ter nossas bibliotecas atualizadas, saiu um novo release lá estamos nós atualizando, e resolvemos testar as novas versões do IReport, porém nenhuma delas funcionava com EJB Connection, e existia um maldito EJBCascadingStyle, que a única coisa que pesquisando encontrei, foi referencia errada da versão do Hibernate. E eu atualizando os jar no diretorio ext no IReport e o erro persistia, então navegando encontrei uma solução, aparentemente, era copiar os jars principais do meu projeto no diretorio IREPORT_HOME/plataform9/lib
Realmente conectou usando EJB Connection, porém uma lesma ganharia na velocidade, o IReport ficou intrabalhavel, não conseguia editar um jasper qualquer quem diria criar um novo. Abandonamos e voltamos para a versão 3.0.
Buscando agora encontrei um topico realmente interessante, e esse sim fez o IReport funcionar. Resumindo oq vc precisa é ir ao diretorio IREPORT_HOME/ireport/modules/ext
e REMOVER as libs ehcache, hibernate3, hibernate-annotations, hibernate-commons-annotations e jpa
e adicionar esses jar do seu projeto :D, assim funciona, agora encontrei um NullPointer na hora de editar a query, quem sabe até amanha eu consiga usar essa nova versão :P
Ehehhe, brincadeiras a parte, esses tempos tive um pequeno problema com uma certa demora usando JPA em um modulo EJB.
Tive de fazer a rotina de leitura de um arquivo texto e importar os registros para o sistema. até ai sem problemas, fiz a rotina e ela rodava em menos de 5s e importava todos os registros. Porém os registros que vinham no arquivo não atendiam a modelagem do sistema, ou seja, teria que inserir nas outras tabelas caso não existisse.
feita as Querys para encontrar o registro, e caso não existisse criar um novo, do nada ele demorou aproximadamento 6hrs e ao final la pela 1h30min da manhã uma execessão de No Transaction Active foi lançada em um flush no Entity Manager.
Lá fui eu aplicar algums caches de memoria para diminuir as consultas ao banco e os salvamentos. resolvemos mudar alguns merges para persist pois seguindo o que o pessoal fala, o persist é somente para objetos novos e é muito mais rapido.
Pois é não foi. Os objetos usando persist se tornaram pesados, e o procedimento ficou pesado, interrompido em 30min de execução tendo percorrido somente 200 registros (o arquivo possuia 30k). Removi o persist e deixei tudo como merge, mais uma vez uma No Transaction lá pelo registro 3mil é lançada. mais por que existe transação até o 2999. Eis que me dizem, põe um clear no começo do loop.
Galera, nunca vi o treco ir tão rápido ehhehe. Todo o gargalo de processamento se foi e o procedimento rodou em 5min.
Pra quem já teve esse problema não esqueça, o clear é muito importante :)
Aproveitando que estou falando sobre JPA e EJB... Estavamos também com um problema ao salvar (merge) alguns objetos, a performance muito baixa, levava quase 2min para salvar o objeto, isso pos a chamada do em.merge.
Fiz varios testes, inclusive usando o clear, porém não deu em nada, resolvi arriscar, o problema estava nos objetos que eram atualizados e vinham do cliente, ou seja, estavam foram do contexto do EJB e do entity manager. Não sei se isso é gambiarra ou não, mas a performance melhorou drasticamente caindo para 2s.
primeiro passo eu recupero o objeto usando o em.find.
depois atribuo a esse objeto recuperado o objeto passado como parametro
dai só fazer o merge
Simples e pratico não :)
Espero que isso seja de ajuda para mais alguém. Até a próxima
Acredito que a maioria dos desenvolvedores ao menos uma vez mediu o tempo de execução de um método na aplicação. Para quem como eu meche com Java, muitas vezes recorremos ao System.currentTimeMillis():
Long agora = System.currentTimeMillis(); //Algum método demorado System.out.println((System.currentTimeMillis()-agora)+"ms");
A saída desse código é o tempo de execução em milisegundos, bem simples, já é algo ilustrativo para medir o desempenho da aplicação, porém muitas vezes isso não tem todas as informações que gostaríamos de ter. Eis que algum louco inventou um tal de perf4j, uma biblioteca parecida com o log4j, mas voltada para medir a performance da aplicação (O log4j é uma biblioteca de log). Através do perf4j, é possível até gerar gráficos de desempenho, e ele também mostra o tempo médio de execução dos métodos durante a execução. Vou mostra uma maneira simples de se usar o perf4j mesclado com o Java Logging API, assim podemos salvar os resultados da performance em um arquivo e lê-los quando precisarmos. O perf4j funciona baseado na classe StopWatch, e apartir dela podemos gerar as nossas estatísticas. Inicialmente o código vai ficar maior porém os dados que podemos conseguir em cima disso são bem maiores.
OBS: Já tive problemas com essa manipulação de arquivos e locks do Sistema operacional, quando estamos trabalhando com arquivos, o ideal é sincronizar e tornar a leitura do arquivo Thread Safe
String arquivo = "statistics.log";//nome do arquivo que será armazena as estatisticas Logger logger = Logger.getLogger("com.rollingwithcode");//Qualquer pacote serve. logger.addHandler(new FileHandler(arquivo));//adiciona ao log o arquivo como handler, a Java Logging API, usa esse arquivo para armazenar o log. StopWatch stop = new JavaLogStopWatch("Teste", logger);//o primeiro argumento é o nome ilustrativo desse log, cada método deve ter seu próprio nome, assim se torna mais intuitivo e mais especifico quando se lê o arquivo. //Aqui vem alguma execução que pode ser demorada. stop.stop();
Após a execução da ultima linha algo como: 24/08/2009 13:43:32 org.perf4j.javalog.JavaLogStopWatch log INFO: start[1251132212406] time[406] tag[Teste] Deverá ser exibido na console. Essa saída é até menos legível que a do System.currentTimeMillis(), porém o poder do per4j será mostrado a seguir.
Vamos ler o arquivo de log gerado, seria interessante executar mais alguns métodos para armazenar no log, o per4j trabalha com uma classe chamada LogParser para gerar estatísticas em cima do arquivo de log gerado (statistics.log).
String arquivo = "statistics.log"; String temp = "lido.log";//Arquivo temporário, os dados são jogados do statistics para esse outro arquivo de log. LogParser parser = new LogParser(new BufferedReader(new FileReader(arquivo)), new PrintStream(new FileOutputStream(temp), true), null, 30000L, false, new GroupedTimingStatisticsTextFormatter()); parser.parseLog();
A criação do LogParser é simples, primeiro argumento é o arquivo de log que geramos através do StopWatch, o segundo é o arquivo temporário a ser salvo, o terceiro parâmetro (null) é utilizado para gráficos, os outros dois parametros não vem ao caso agora, o ultimo parâmetro é o formatador do arquivo temporário, define o layout do arquivo.
O método parseLog faz a leitura do arquivo. Agora basta você ver o arquivo lido.log e termos o arquivo legível trazendo a media de tempo de execução do arquivo (Avg), o tempo mínimo (Min), o tempo máximo (Max), a quantidade de vezes que o método foi chamado (Count). Agora sim as informações são bem maiores não acham?
Aconselho o uso do perf4j, excelente ferramenta para analise de performance em Java.
Estava eu pensando esses dias, se posso executar código java via Jruby por que não o contrário? Quais as minhas chances de usar Jruby dentro do Java?
Então la fui eu ao oraculo, e começei a buscar, ouvi falar de um JSR XXX (preencha com o número que quiser, nunca me lembro desses números, que pra mim são irrelevantes), que define o Java ScriptEngine, que nada mais é do que usar scripts dentro do Java, no Java 6, já vem com superte a Rhino (JavaScript), embutido, mas exemplos usando JavaScript tem de monte, vou lhes mostrar como instanciar uma classe via JRuby e chamar alguns metodos dessa classe no java. Não vou dizer que isso vai ficar bom, mas enfim, quem sabe melhorem futuramente essas engines, Mesmo assim você não precisa massacrar seu codigo java para migra-lo para JRuby, pode simplemente adaptar o codigo do JRuby no Java. Vamos ao exemplo, primeiramente vejamos quais nossas engines disponiveis na nossa versão.
public static void main(String[] args) throws Exception{
ScriptEngineManager manager = new ScriptEngineManager();
for(ScriptEngineFactory factory : manager.getEngineFactories()){
System.out.println(factory.getEngineName());
}
}
}
A saida deve ser Mozilla Rhino, lembre-se java 6, eu não tenho bem certeza, mas acho que o ScriptEngine está disponivel na versão 5, porém sem nenhuma engine disponivel.
E ai tio e agora como que nos faz?
Vamos adicionar o Jruby, no site do projeto baixem os script-engines, com isso temos as libs de diversas linguagens suportadas que podemos utilizar, para nos interessa, o que esta dentro da pasta jruby/build, o jruby-engine.jar deve ser adicionado ao seu classpath, ainda existem outro jar a ser adicionado, se você olhar outros tutoriais, ele vai passar diversos jar que não estão mais no $JRUBY_HOME/lib, ignore :), adicione ao classpath do seu projeto somente o jruby.jar, e agora sim. Se executar o programinha de antes deve aparecer agora
Mozilla Rhino
Jruby Engine
Vamos para o nosso querido Hello World (eu sei, eu sei, todos vocês amam o Hello World (: )
public static void main(String[] args) throws Exception{
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("jruby");//Buscamos a Engine do Jruby
engine.eval("puts 'Hello World'");//Codigo JRuby
}
}
ao executar temos a mesma saida do Println, não é magico? Heeheh, um puts executado via java. Sei exatamente o que a maioria pensou, vou ter que por todo o codigo Jruby num String? A reposta é não :), a não ser que você queira fazer isso, mas eu não aconselho.
Existem outros metodos para recuperar as engines, e um deles é por extensão, poderiamos ter usado o metodo getEngineByExtension e passar como parametro o “rb”, e teriamos o Jruby.
Vamos criar então uma classe bem bunito um arquivo .rb
class Teste
attr_accessor :name, :age
def set_name(name)
self.name = name
end
def set_age(age)
self.age = age
end
def toString
self.name+" "+self.age.to_s
end
end
Lembrando que o toString sobrescreve o metodo toString do java sem problemas algum, os metodos set_ foram definidos para seguir as convensões do ruby, e isso vai tornar nosso codigo java feio, e não digam que não avisei. Vamos criar uma pequena interface
public interface Teste {
String name();
void set_name(String name);
Integer age();
void set_age(Integer age);
}
notem o estilo que foi declarado os metodos set_ na interface tbm, deve haver alguma maneira de fazer isso automatico, se alguem souber me avisa :)
E agora tio? Vamos brincar um pouco de ScriptEngine?
public static void main(String[] args) throws Exception{
ScriptEngineManager manager = new ScriptEngineManager();
for(ScriptEngineFactory factory : manager.getEngineFactories()){
System.out.println(factory.getEngineName());
}
ScriptEngine engine = manager.getEngineByName("jruby");
engine.eval(new FileReader("src/com/rollingwithcode/testejruby/teste.rb"));//arquivo .rb
Object instance = engine.eval("@teste = Teste.new");//crio a instancia
Invocable inv = (Invocable) engine;
Teste teste = inv.getInterface(instance, Teste.class); //converto a classe em uma Interface Java
teste.set_name("Rafael");
teste.set_age(21);
System.out.println(teste.toString());
System.out.println(teste.name());
}
E adivinhem a saida:
Rafael 21
Rafael
Tudo isso só pra misturar um pouco de Ruby com java, credo, parece coisa de loco :)
vou investigar mais algo, e ver se existem maneiras de melhorar isso.
É engraçado ver como os servidores LDAP não vem sendo aproveitados. Na verdade são poucas as linguagens onde a comunidade tem algo para usar com servidores LDAP. No caso do Java existe uma biblioteca o JLDAP, distribuida pela Novell que ajuda o trabalho. É uma biblitoeca bem sfemples e mais facil de utilizar que usar JNDI para comunicar com o servidor LDAP.
Porém muita gente tem dificuldade em criar o servidor e efetuar ações dentro de um servidor LDAP, vou utilizar aqui nesse exemplo o Apache Directory Server como servidor LDAP, então as strings de acesso vão depender muito do servidor que você estará utilizando. Existem ferramentas para explorar os servidores então pode não ser tão dificil assim, basta dar uma espiada no senhor da internet (Google) e acharás o que procuras :).
Começando com o JLDAP:
A base de uma conexão com o servidor LDAP é baseada na classe LDAPConnection, e diferente dos banco de dados, não é a conexão que importa e sim o bind dela. Atraves desse bind o servidor disponibiliza os recursos de acordo com as permissoes do usuário que fez o bind. Exemplo:
LDAPConnection conn = new LDAPConnection();
conn.connect(“localhost”, 37); //Esses dois parametros são servidor (IP ou Nome) e a porta de conexão
conn.bind(LDAPConnection.LDAP_V3, “uid=admin,ou=system”, “secret”.getBytes());
Percebam o bind, ele é composto por versão do servidor LDAP, o DN do usuário a ser logado, lembrem-se o LDAP não funciona como usuário e senha, e talvez precisem ler mais sobre ele e suas siglas, DN, CN, RDN etc. E o ultimo parametro e a senha em um array de byte.
Após esse código existe uma conexão com o servidor LDAP. E podemos manipula-la.
Vamos criar uma nova entidade dentro do servidor LDAP. Vou utilizar a classe Person (Os servidores LDAP também são divididos em classes, são chamadas de objectClass, e essas classes identificam o tipo do registro no servidor), responsavel por cadastrar usuários no servidor LDAP.
LDAPAttributeSet attributes = new LDAPAttributeSet();//Um Set de atributos para o servidor, funciona no formato chave => valor.
attributes.add(new LDAPAttribute("objectClass", "person"));
attributes.add(new LDAPAttribute("cn", "felix"));
attributes.add(new LDAPAttribute("sn", "felix"));
attributes.add(new LDAPAttribute("userpassword", "teste"));
attributes.add(new LDAPAttribute("telephonenumber", "11111111"));
attributes.add(new LDAPAttribute("description", "Eu"));
//Definimos o DN, lembrem-se ele sempre é único e tera uma exception caso não seja único
String dn = "cn=felix,ou=users,ou=system";//Isso pode variar de acordo com o servidor LDAP que você estiver utilizando.
LDAPEntry entry = new LDAPEntry(dn, attributes);
conn.add(entry);//insere a entidade.
bacana Não é? E o mais legal, funciona :). Levei algum tempo para conseguir isso, mas assim é mais simples. Lembrando que deve-se ter um conhecimento básico em LDAP. O dn é formado normalmente pelo cn do usuário e o restante compreende a hierarquia de arvore do LDAP. Vendo como um diretorio seria um arquivo chamado felix dentro da pasta users que esta dentro da pasta system, simple não? E ainda por cima vc pode usar esse DN recem inserido para fazer login no servidor LDAP.
Vamos para a segunda parte. Pesquisar registros.
A pesquisa é baseada na classe LDAPSearchResults, e se basea na busca atraves da arvore de diretorios ou de um DN. A pesquisa aqui vai ser baseada na árvore que acabamos de inserir um registro (ou=users,ou=system), e vamos ver todos os usuários do sistema.
LDAPSearchResults search = conn.search(“ou=users,ou=system”, LDAPConnection.SCOPE_ONE, null, null, false); //não to lembrado do por que desses parametros :P
while(search.hasMore()){//Auto explicativo
LDAPEntry entry = search.next()://Recuperamos a entidade. Cada uma dessas entidades é um usuário do servidor LDAP.
//Vamos carregar e imprimir os atributos desse usuário
LDAPAttributeSet attribute = entry.getAttributeSet();
Iterator it = attribute.iterator();
while(it.hasNext()){
LDAPAttribute att = (LDAPAttribute) it.next();
System.out.println(att.getName() + “ => “ + att.getStringValue());
}
System.out.println();
}
Simples não? E ainda tem gente que acha dificil acessar servidor LDAP via Java :)
Espero que esse post seja util a quem está buscando algo como acessar servidores LDAP.
Quem já mecheu com Swing conheçe o parto que é testar as telas. Pensar nas mil possibilidades se fazer cagada em uma tela. Impossivel prever o total de coisas que um usuário consegue fazer. Para facilitar esses testes surgiu o JUnit, automatizando os testes. Não vou entrar em detalhes sobre o TDD, existe muita informação por ai.
Mas algum tempo atrás procurei por algo para automatizar os testes em Interfaces gráficas. Porém nada do que eu achei era o que eu buscava. Não queria ter que abrir a tela e inserir valores. Gostaria de fazer isso via código de forma automatica, como o JUnit, em busca de um resultado esperado. Vi sobre o Maraton, FestSwing, e em todos eu tinha que abrir a droga das telas para testar. Algo que não me agradou nem um pouco.
Então deixei de lado isso. Porém alguns dias atraz me veio uma ideia meio louca de se fazer isso. Criei uma classe que encapsula o frame. e atraves dela consigo recuperar os compoenentes da tela e simular as ações. Exatemente o que eu queria. Automatizar a porcaria do teste (:
Image o seguinte JInternalFrame:
A ação do botão se resume a alterar o texto de JInternalFrame para Clicked.
E ai? como fazer para testar esse esquema?
public class TestFrameWithMock {
private SwingTester mock;
public TestFrameWithMock() {
mock = new SwingTester(new TesteInternal());
}
E ai alguém ai percebeu como é simples o esquema? E nenhuma tela é visivel. A maioria das ferramentes você deveria abrir cada JInternalFrame, um por um e testa-lo. Assim desse modo com a Classe SwingTester ele não é visivel.
Como podem perceber o TesteInternal (JInternalFrame da imagem) é passado como parametro. E atraves dele é possivel recuperar os compoenentes da tela atraves do atributo name de cada um ou atraves do nome da variavel via reflection (que foi usado nesse teste acima). E o teste executa sem problemas.
Foi a abordagem que achei mais legal. Em breve for colocar isso ai no github, se eu lembrar e vcs podem analisar e testar.
Bom terça-feira dia 24/03/2009 foi minha apresentação do meu trabalho de conclusão de curso. Engraço que tudo isso me fez lembrar do começo da faculdade, desde quando entrei, até agora. E pensar que entrei sem nem ter noção do que era desenvolver um software, e hoje ser um desenvolvedor.
Na verdade quase me dei mal na apresentação, no nervosismo apresentei em 11 minutos quando deveria ter apresentado em 15, fui mostrar a apresentação utilizando uma digamos assim "gambiarra", para mostrar funcionando a aplicação, mas Murphy é infalivel e a aplicação não funcionou, na hora o branco de não saber como agir me deixou sem muitas escolhas, mas no fim correu tudo bem, mesmo sem mostrar a aplicação. Eu espero ao menos. Ainda me resta entregar o trabalho escrito, mas esse só ajustar a metodologia dele.
Do que se tratava meu trabalho, basicamente é uma ferramente para alterar usuários em um servidor LDAP atraves do Celular. Utilizei somente linguagem Java, JSON, RESTful e o Apache Directory Server. O sistema atraves do emulador executa todo o CRUD sobre um Usuário do servidor LDAP, porém rodando do aparelho existe um problema na edição de usuários. E a aplicação não está tão completa, faltaram validações, e diversas implementações. Algumas coisas faria melhor, mas nem sei se vou continuar com o projeto.
O projeto na verdade é divido em 4 partes, a API de comunicação com o LDAP, a implementação da API, focada no ApacheDS, os serviços RESTful, e a aplicação cliente. Os fontes são interessantes para quem quer ver como funciona a comunicação com o LDAP partindo do Java, e como utilizar JSON tanto em Java como em JavaME.
O título apesar de estranho, é justamente disso que vou falar JSON com Java (café), andei pesquisando diversos formatos de arquivos para usar no meu TCC, dentre eles o XML, que para quem não sabe é muito custoso para um celular processar esse tipo de arquivo, o YAML (o qual não possui nenhum biblioteca para ser tratado com JME), e o ultimo é o que eu mais me encantei o JSON.
JSON foi criado baseado em JavaScript. Porém ganhou notaridade, e foi implementada por diversas linguagens, no site oficial se encontra uma biblioteca para ser usado em Java, com o codigo fonte la. Foi esse que usei nesse exemplo, podem baixar nesse link http://www.json.org/java/index.html
Muito simples trabalhar com JSON e Java. O JSON funciona como um Map, utilizando a combinação chave => valor, uma chave sempre é uma String, e o valor pode varias, os valores disponiveis para o JSON podem ser vistos no site json.org.
Após adicionar as classes ao seu projeto vamos a utilização da biblioteca.
Basicamente a biblioteca consiste nos objetos JSONObject, JSONArray e JSONException
Onde JSONObject representa um único objeto no formato JSON e JSONArray representa uma coleção de objetos.
Usando JSONObject
JSONObject obj = new JSONObject();
obj.put("nome", "Rafael");
obj.put("idade", 21);
System.out.println(obj);
a saída sera algo como:
{ "nome":"Rafael", "idade":21 }
Perfeito não? muito simples. Calma que tem mais
public class Pessoa{
private String nome;
private int idade;
//Gets e Sets
}
Criamos um objeto para comportar as alterações. e para converte-lo em JSON?
Pessoa p = new Pessoa();
p.setNome("Rafael");
p.setIdade(21);
JSONObject obj = new JSONObject(p);
System.out.println(obj);
E a saída?
{ "nome":"Rafael", "idade":21 }
Um JSONArray segue a mesma linha de raciocionio, com a diferença que vc adiciona a ele diversos JSONObject ou Strings no formato JSON. excelente para quem quer trabalhar com esse arquivo em formato leve.
Segundo a wikipedia: O padrão obsever diz que um objeto (observado) mantem uma lista de outros objetos (observadores), e notifica aos observadores qualquer mudança que ocorro no observado.
O Java já traz uma implementação do observer padrão, e a utilizamos aqui onde trabalho pra implementar o MVC com Swing, e realmente achei uma abordagem muito interesse, e simples de ser feita.
é muito simples de se utilizar, e esse post vai ser pequeno sim :).
primeiramente na nossa classe observada temos que fazela extender a Obervable e isso já a torna apta para ser observada por outra classe, as classes que vão observala devem implementar a interface Observer que contem a assinatura de um único metodo update, a cada notificação do modelo é chamado esse metodo update, ridiculamente simples e facil.
Vamos a um exemplo prático:
public class MeuObservado extends Observable{
public void hello(){
setChanged();
notifyObservers("Hello World!");
}
}
Agora quem vai observar essa classe
public class MeuObservador implements Observer{
public MeuObservador(){
MeuObservado obj = new MeuObservado();
obj.addObserver(this);
obj.hello();
}
public void update(Observer o, Object arg){
System.out.println(arg);
}
}
só executar e pronto, um hello world utilizando observer, se vc tiver mais classes que utilizem esse hello world basta adiciona-la ao observer, e ela será notificada também. simples, pratico e facil. Excelente maneira de proporcionar baixo acoplamento entre as classes.
Outra hora vou postar sobre como criar listener no Swing.
O CouchDB, é um banco de dados Orientado a documentos, diferente dos banco de dados orientados a tabelas, ele é mais dinamico, e dizem por ai que ele escala, diferente dos banco de dados relacionais. CouchDB é um projeto da apache, e nem na versão 1.0 está ainda, mas já causou enorme alvoroso na comunidade Rails. Existem algumas soluções para usar o CouchDB com Rails, e em java temos somente uma que é o CouchDB4J, mas para mexer com ela é necessário reaprender a mexer.
Lógico que a estrutura do CouchDB é bem diferente de outros banco de dados, ele funciona a base de requisições RESTful, e troca arquivos no formato JSON, entre cada Requisição, ele é baseado em Requests e Responses HTTP.
Eis que procurando, até para testar não há nenhuma implementação que tente seguir o padrão JDBC para o CouchDB, então, começei a implementar, e nem é tão complexo assim, secretamente em baixo de cada comando ha uma requisição HTTP no projeto. Vou em breve disponibiliza-lo no meu github, para quem quiser contribuir, a versão já tem algumas informações uteis, já é possivel consultar alguns documentos do servidor atravez de ResultSet e Statment.
Quem tiver interesse em ajudar, é só falar comigo para começarmos a pensar em como desenvolver melhor esse driver.
Ficou interessado no CouchDB? Infelizmente ele ainda não tem uma distribuição em binários, somente código fonte. Podem baixar os fontes, e ver no README do CouchDB como instalar no Ubuntu e no Mac OS, usuários de windows, tentem novamente mais tarde.
Ele possui uma interface web bem simples e bacana para se aprender a mexer, estou querendo aprender a mexer mais, se alguem quiser compartilhar conhecimentos so falar comigo.
O que são as annotations? Na verdade uma annotation não é nada, somente um enfeite para seu código. WTF? então como elas servem para fazer alguma coisa? Como que eu anoto com @Id meu JPA e ele reconheçe isso?
Na verdade não é a anotação que vai fazer isso, e sim uma outra classe responsavel por ler suas classes e identificar quais possuem a anotação, e você que criou aquela anotação simples, vai ter que escrever essa classe. Calma não se desespere, vou explicar como funciona :).
Para criar uma Anotação devemos criar uma interface Java, mas com algumas pequenas mudanças vejam a anotação abaixo
public @interface Teste{ String valor(); }
pronto temos uma anotação criada, o campo abaixo é um atributo da anotação algo que a anotação deve obrigatoriamente conter, você pode deixa-la opcional, adicionando a opção "default"
public @interface Teste{ String valor() default ""; }
As anotações são objetos simples, e eles não aceitam valores null. Vc não pode passar um objeto por exemplo seu JPA para uma anotação (infelizmente).
E agora para usar como q faz? vamos criar uma classe de ajuda para nós aqui, ela será a classe que irá executar o comando:
public class Main{ @Teste(valor="teste") private String teste;
public static void main(String[] args){
} }
Nossa anotação esta funcionando, mas se vc executar o programa vc simplesmente não verá nada. Mas por que? A Anotação é so um enfeite, existe toda uma programação em reflection por traz (gambiarra?), mas não é tão complicado assim, vamos criar uma classe AnnotationResolver, que vai verificar as anotações para nós:
public class AnnotationResolver{ private Class classe; private Field[] fields; public AnnotationResolver(Class classe){ this.classe = classe; //Isso é reflection carregamos todos os campos da classe informada //Esses campos são todos os atributos declarados na classe. this.fields = classe.getDeclaredFields(); } public void resolve(){ for(Field f : fields){ //Eis aqui a magica do reflection //Perguntamos se o campo tem uma anotação, e informamos a classe dessa anotação if(f.isAnnotationPresent(Teste.class){ //Podemos pegar a instancia da anotação desse campo dessa maneira, e assim //acessar os campos da anotação Teste teste f.getAnnotation(Teste.class); System.out.println(teste.valor()); } } } }
Para testar nossa classe vamo esditar o metodo main da classe Main, o restante do código já informado acima foi omitido
//Codigo omitido public static void main(String[] args){ new AnnotationResolver(Main.class).resolve(); }
Simples assim temos nossa chamada e veremos nossa anotação funcionando, execute o programa. E vamos ao resultado:
Nada.
WTF? O Que eu fiz errado? por que isso não funciona? Bom apanhei muito para isso funcionar, a anotação tem que ter algumas anotações também (rá), primeiro você deve indicar em que momento a anotação deve ser verificada e depois informar qual o objetivo dela, se ela atige Classes, Metodos ou campos. basta editar nossa anotação e adicionar:
@Retention(RetentionPolicy.RUNTIME) @Target(ElementType.FIELD) public @interface Teste{ //Codigo omitido }
Meio estranho fazer isso mais eu sempre uso o @Retention como RUNTIME, pois é normalmente a hora que eu gosto que as anotações sejam conferidas. Agora compile e rode seu programa.
E veja só não é que funcionou? Agora sim você tem um enfeite util para seu projeto Java (nem tão util assim no nosso exemplo).
Esse eu descobri fuçando na net, pois a muito pouco material sobre isso, que seria como usar o metodo PUT utilizando JME. Atualmente estou na 9ª fase do Curso de Ciência da Computação na UNOESC, a ultima fase do curso, e estou desenvolvendo meu TCC (Trabalho de Conclusão de Curso), meu projeto consiste em prover acesso a um servidor LDAP (O padrão LDAP, não em um serviço especifico), pelo celular, na verdade irei construir somente um prototipo da aplicação aonde seja possivel criar, editar, excluir e listar os usuários do LDAP. No começo do projeto, minha intenção seria usar Web Services (XML) e consumir os retorno com o JME, porém ao pesquisar as APIs de consumo de XML para JME, elas são mal documentadas, e os exemplos são criados pela comunidade, algumas APIs você nem acha aonde baixar. Sem contar que o consumo de XML no celular é muito custoso para o aparelho que não tem muitos recursos, eis que a nova versão do NetBeans veio com suporte a RESTful, e resolvi fazer alguns testes, inicialmente iria usar o KXML, e transmitir XML usando RESTful, a listagem eu consegui pegar com a ajuda do jLDAP, uma biblioteca do novell para ajudar a comunicar o java com o LDAP, a biblioteca é bem simples de se usar, e achei ela muito interessante. Bah, eu não tava afim de usar a biblioteca de parser de XML, não funcionava como eu gostaria, e era bem limita, eis que me surge uma idéia de usar JSON, o Java Script Object Notation, que é um formato de arquivo leve parecido com o YAML, mais para minha felicidade, havia bibliotecas para Java e JME para JSON. Maravilha, e ainda por cima o RESTful do Java tem suporte a compoartilhar aquivos JSON. O GET novamente funcionou perfeitamente, mas e o PUT? não havia jeito de funcionar, e o metodo HTTPConnection do JME suporta somente o GET e POST. Como resolver isso? Pesquisando na net axei o seguinte post, que falava para simular o PUT como o Rails faz, porém não obtive sucesso dessa maneira, o jeito que encontrei foi o de usar um metodo POST, que consome um JSON e produz um text/plain, seguindo as definições do POST ele precisa retornar algo, vejam o código abaixo:
@POST @Produces("application/json") @Consumes("text/plain") public String postJson(String content){ try { JSONObject obj = new JSONObject(content); Person person = new PersonApacheDs().fromJSON(obj); dao.save(person); } catch (LDAPException ex) { ex.printStackTrace(); return ex.getMessage(); } catch (JSONException ex) { ex.printStackTrace(); return ex.getMessage(); } return "OK"; }
existem algumas classes ai que são do meu projeto é não vou explica-las agora :). Desse modo consegui criar um serviço post que funcione para inserir dados, esse não é o metodo certo, o ideal seria usar o PUT, ainda vou fazer alguns testes, ver bem certo como o rails trabalha com o PUT, e depois eu experimento. No exemplo do outro blog, acima, ele mandava passar a data na URL, agora imagine passar um arquivo JSON na URL? Lógico que não foi aceito, por isso resolvi usar o POST. E para se comunicar é simples, primeiramente você usa um OutputStream para transmitir seus dados.
HttpConnection con = (HttpConnection) Connector.open(url, Connector.READ_WRITE); con.setRequestMethod(HttpConnection.POST); DataOutputStream dos = con.openDataOutputStream(); String json = obj.toString(); byte[] b = json.getBytes(); for (int i = 0; i < json.length(); i++) { dos.writeByte(b[i]); } dos.flush();
obj é um objeto do tipo JSONObject, que cria o objeto no formato JSON, e para ler vc cria um InputStream atravez da conexão, e pronto, você se comunica perfeitamente com um Serviço REST, meu próximo teste é tentar comunicar com o Rails, que pra quem não sabe utiliza o REST por padrão em todas as paginas.
Isso ai galera, espero que gostem, qualquer dúvida, ou se alguem conseguiu usar o PUT deixem um comentario ou me mandem por e-mail.
Galera essa foi muito boa, eu procurando sobre usar o BDD em Java, algo parecido com o RSpec, que gosto tanto, e me familiarizei fácil usando no Rails. Achei um que pareceu interessante o JBehave, porém parecia mais com os Stories do RSpec, é não com os Spec, que era justamente o que eu queria, também encontrei um tal de JDave, mas ainda é um projeto embrionário, e resolvi procurar se havia uma versão do RSpec para Java, eis que caio no Blog do Ola Bini, um dos Team Leaders do JRuby, e ele mostra usando o RSpec com Java usando JRuby. Não era bem isso que queria, mas mesmo assim, resolvi experimentar, nunca mexi muito com o JRuby, já brinquei com Java e Ruby separados mas não nessa versão, usando recurso das duas linguagens juntas. Então lá fui eu copiar o exemplo do Ola Bini, e para minha surpresa funcionou muito bem, melhor do que eu esperava. Então pequei um código e comecei a testar para ver se funcionava com minhas entidades, testar um programa escrito em puro Java, em outras palavras usar as classes do Projeto e as do Ruby juntas.
Então comecei a luta para o JRuby reconhecer minhas classes, e após algumas tentativas frustradas, que incluíam adicionar o jar do Projeto no classpath, não funcionou. Estava pronto para estudar o JDave ou o JBehave, quando recorri ao senhor supremo da internet, o Google. Encontrei uma wiki sobre JRuby, e lá tinha um código relativamente ridículo, que eles diziam que adicionava a biblioteca ao JRuby. Vejam o código simples:
require "caminho/para/arquivo.jar" module Models include_package "pacote/suppacote" end
Um Module em ruby, é quase uma classe, ele é um complemento para uma classe, todo o código de um module incorporado a uma classe pode ser usado, sem restrição (ou talvez haja e eu não sei, não estudei muito essa parte.). Esse module só vai simplificar nosso trabalho, ao invés de fazer a chamada usando o padrão do JRuby que é de:
pacote.subpacote.Classe
Chamamos direto pelo estilo Ruby de Models::Classe, pode parecer poca coisa mais se você for seguir as convenções da Sun da um caminho grande até a classe.
Agora sim podemos criar nossos testes com o JRuby usando projetos Java. Vocês podem ver o exemplo do Ola Bini, e testar suas classe com o RSpec, caso não saiba ainda utilizar o RSpec, é uma chance de aprender. Para você usar na sua classe de Teste, tem que adicionar também no início do arquivo o require do seu module como, por exemplo:
require "caminho/para/models.rb"
Assim você pode usar qualquer classe do seu Projeto.jar sem problemas e testa-las usando RSpec. Pra que sofrer com JUnit?
Logo logo sai um artigo sobre MVC em PHP a pedido do meu amigo Renato, aguardem.
O Java Record surgiu com uma idéia de evitar as dificuldades de se mapear classe por classe usando Hibernate, seja com os .hbm.xml ou com Annotations, lógico que a segunda alternativa, é a mais rápida, porem eu como um verdadeiro programador a moda antiga, gosta de configurações, prefiro escrever 900 xml do que usar annotations. Lógico que isso não quer dizer não use annotations, eu as usei, e confesso que achei muito eficiente. Mas não era isso que eu queria, dava muito trabalho, eu como costumo seguir as regras da normalização, acabo gerando diversos models para simples cadastros, e era trabalhoso de mais configurar todos os XML.
Eis que me aventuro no mundo do Ruby on Rails, já havia tentado a muito tempo atrás, mas não havia gostado muito, hoje com mais conhecimento, consegui ver vantagens na linguagem, e lógico comecei do jeito certo, pelo Ruby, na outra vez me taquei direto no Rails, que não aconselho a ninguém não foi uma experiência muito agradável, era basicamente CTRL C + CTRL V. E pesquisando mais a fundo sobre o funcionamento do Active Record (O ORM do Rails), percebi que ele era simples pois, perguntava para o banco quais seus atributos, na hora me veio na cabeça ResultSetMetaData, que faz a mesma coisa, retorna as colunas de uma tabela, e pensei que poderia usar isso para facilitar o desenvolvimento dos meus models nas brincadeiras que fazia.
Então comecei a escrever o JavaRecord, meu objetivo era agilizar o trabalho, porém eu precisaria de um arquivo de configuração, para pelo menos me indicar aonde conectar, eis que surgiu o config.yml. Mas por que YAML? YAML é um formato de texto simples e fácil de ser lido, é rápido e facilmente processado pela aplicação, e é muito fácil de ser lido, sem todas aquelas frescuras do XML. Assim comentei com alguns colegas meu da faculdade, e acharam a idéia interessante, resolvi ver o que o pessoal o Java.net achava da minha idéia, e ela foi aprovada no Java.net, então começou um projeto Open Source para Java, atualmente na versão 0.1.1 o projeto é bem fácil de ser utilizado em bancos MySQL, porém um teste com o Oracle me decepcionou, como eu pude esquecer das seqüências? Agora estou em um dilema como vou adicionar as seqüências do Oracle? Não quero adicionar mais configurações, e estou até pensando em criar um esquema de dialetos. O próximo passo é criar automaticamente os vínculos com chaves primarias, evitando assim mais uma configuração.
Para quem quiser ver um exemplo funcional clique aqui e veja um PDF mostrando o funcionamento do JavaRecord. E para fazer o download do JavaRecord com dependências acesse o sourceforge.net.
