? Android: ORMLite – 2. O gerenciamento de chaves estrangeiras em ORMLite é um pouco diferente do que normalmente é feito em outros frameworks de ORM, como? o Hibernate. Basicamente, são utilizadas as seguintes anotações para este gerenciamento: @ForeignCollectionField – Para coleções estrangeiras. Obs.: O ORMLite suporta apenas que as coleções sejam: ForeignCollection ou Collection,…
Databases em Android (ORMLite) – 4
Databases em Android (ORMLite) – 3
? Android: ORMLite Feita a introdução básica sobre como o android manipula e gerencia bancos de dados, podemos avançar para um tópico, digamos, um pouco mais avançado e que tornará nossas iterações com os bancos de dados em Android muito mais fáceis. ORMLite, ou Object Relational Mapping Lite, é um framework que (como descrito em…
Oportunidade para Desenvolvedor de Sistemas Mobile – Rio de Janeiro
A Cyberlynxx está com uma oportunidade para Desenvolvedor de Sistemas Mobile. Segue requisitos da oportunidade: – Programação: ASP.Net, C#, Javascript, PL/SQL; – Banco de dados : SQL Server e/ou Oracle; – Experiência em trabalhar com Framework 3.5 ou superior; – Experiência em desenvolvimento de sistema para Windows Mobile; – Conhecimento de gravação e leitura de [...]
Já está aberta a venda do livro jQuery Mobile na Prática. Por apenas R$ 10,00, você terá a chance de conhecer este framework do melhor jeito possÃvel, através de exemplos práticos!
O lançamento ocorrerá no dia 27/02.
Muitas surpresas estão por vir, aguarde!
http://www.danielschmitz.com.br/jquery-mobile-na-pratica.html
Veja mais neste post.
Ele mostra ainda em outro post que o Tour de Flex agora está disponÃvel para iPad.
Flex com PHP usando ZendAMF – Zend_Db
O artigo Adobe Flex com PHP usando ZendAMF – primeiros passos teve como objetivo exemplificar a integração do Flex com PHP para quem já tinha sistemas desenvolvidos usando o AMFPHP, por isso não usei as classes para acesso a banco de dados do ZendFramework. Neste artigo mostrarei o mesmo exemplo mas usando exclusivamente ZendFramework.
Pegarei o mesmo exemplo utilizado no artigo anterior, só modificando a classe PHP para usar as classes de abstração de banco de dados do ZendFramework. Começaremos com nosso gateway.php
-
-
require_once ‘Zend/Config.php’;
-
require_once ‘Zend/Db.php’;
-
require_once ‘Zend/Amf/Server.php’;
-
require_once ‘Zend/Amf/Exception.php’;
-
require_once ‘Zend/Amf/Server.php’;
-
$server = new Zend_Amf_Server();
-
$server->setProduction(false);
-
$server->setClass(‘Contato’);
-
echo($server->handle());
-
?>
Executando o link no seu navegador, deve aparecer a seguinte mensagem:
Zend Amf Endpoint
Em seguida, modificaremos em nossa classe principal, que efetuará as operações de listar, inserir, apagar e atualizar os dados do nosso banco:
-
-
/*
-
* author Leonardo França
-
* site http://www.leonardofranca.com.br
-
*/
-
-
class Contatos
-
-
private $db;
-
private $config;
-
private $select;
-
private $stmt;
-
-
function __construct()
-
-
$params['host'] = ‘localhost’;
-
$params['dbname'] = ‘java’;
-
$params['username'] = ‘root’;
-
$params['password'] = ”;
-
$database['adapter'] = ‘Mysqli’;
-
$database['params'] = $params;
-
$data['database'] = $database;
-
-
$this->config = new Zend_Config($data);
-
$this->db = Zend_Db::factory($this->config->database);
-
-
-
public function getData()
-
-
try
-
-
$this->select = $this->db->select();
-
$this->stmt = $this->select->query();
-
$result = $this->stmt->fetchAll();
-
return $result;
-
-
catch (Exception $e)
-
-
throw new Exception($e->getMessage());
-
-
}
-
-
-
try
-
-
‘nome’ => $data['nome'],
-
‘email’ => $data['email']
-
);
-
$retorno = $this->db->insert(‘tabela’, $dados);
-
return $retorno;
-
-
catch (Exception $e)
-
-
throw new Exception($e->getMessage());
-
-
}
-
-
-
try
-
-
$retorno = $this->db->delete(‘tabela’, ‘id = ‘.$data['id']);
-
return $retorno;
-
-
catch (Exception $e)
-
-
throw new Exception($e->getMessage());
-
-
-
}
-
-
-
try
-
-
‘nome’ => $data['nome'],
-
‘email’ => $data['email']
-
);
-
$where['id = ?'] = $data['id '];
-
return $this->db->update(‘tabela’, $dados, $where);
-
-
catch (Exception $e)
-
-
throw new Exception($e->getMessage());
-
-
}
-
-
}
-
?>
No ActionScript só precisaremos mudar o que será passado para o PHP, ao inves de VOs, mandaremos Arrays:
-
public function insertData():void
-
-
contatosVO['nome']= input_nome.text;
-
contatosVO['email'] = input_email.text;
-
ro.insertData(contatosVO);
-
Referências:
http://framework.zend.com/manual/en/zend.db.adapter.html
Cacoo – Ferramenta de diagramação colaborativa online
Ontem, estava procurando uma ferramenta para desenhar diagramas, que me desse mais op??es de diagramas e fosse mais flexivel do que todas as demais ferramentas que j? havia utilizado at? o momento. Realizando uma busca no Google acabei encontrando a Cacoo.
Site | Google Chrome Web Store
At? o presente momento, utilizando a ferramenta, gostei da facilidade de uso e da quantidade de elementos gr?ficos dispon?veis para utilizar nos diagramas, est? atendendo bem a minha necessidade de cria??o de diagramas.
Veja também:
Injeção de Dependências nos DAOs de Entidades do Framework
A última implementação da HibernateDAOFactory do módulo persist do DCF, agora permite que seus DAOs de entidade possuam propriedades injetadas diretamente do container de beans do Spring.
No exemplo que temos nos testes de projeto, temos o MockDAO, que possui uma propriedade String com nome ‘testeString’:
|
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
public class MockDAO extends HibernateEntityDAO
private String testeString; public MockDAO(SessionFactory sessionFactory) @Override public String getTesteString() @Autowired |
Note que no setter da propriedade, colocamos a anotação @Autowired, para recuperar esta String do container, e também associamos o Qualifier ‘testeString’.
No arquivo de beans do spring, basta adicionarmos um bean String com o id igual ao do qualifier:
|
1
2 3 |
> |
Repare que o valor da String é ‘stringTeste’. Vamos ver em nosso teste agora se tal valor chega corretamente no DAO:
|
1
2 3 4 5 6 7 8 9 10 |
@Test
public void testRightFactory() MockDAO dao = this.getDaoFactory().getDAO(MockEntity.class); Assert.assertNotNull(dao); Assert.assertEquals(this.getDaoFactory(), dao.getDaoFactory()); Assert.assertNotNull(dao.getTesteString()); |
Uma coisa importante a se perceber, é que a chamada da DAOFactory permanece exatamente a mesma, mantendo assim a retro-compatibilidade com as outras versões, e apenas as injeções baseadas em anotações do Spring vão ser consideradas.
NÃO é necessário apontar o component-scan do Spring para o pacote de DAOs de sua aplicação. A injeção de beans adicionais é feita completamente a parte, seguindo o mesmo padrão de nome e de instanciação dos DAOs.
Qualquer dúvida, basta me procurar.
O projeto está no github, dentro do módulo persist do dclick-framework, ou diretamente no nexus da DClick.
Testes Unitários com JUnit – De volta ao básico
Já que ultimamente estamos falando bastante de testes unitários, principalmente aqui na DClick, vamos revisar uma das ferramentas essenciais para executar essa tarefa: JUnit. Mais especificamente, vamos fazer alguns testes com o JUnit 4.8.1, que pode ser encontrado para download no site do projeto, ou até mesmo no repositório do maven.
A proposta desse post é apresentar a ferramenta para quem ainda não conhece, e relembrar ou até mesmo mostrar algumas funcionalidades muito úteis para nosso dia a dia de desenvolvimento.
Um pouco sobre a nova versão
Nas versões anteriores do JUnit, da 3.* pra baixo para ser mais exato, era necessário criar as classes de testes seguindo uma hierarquia pré-definida do JUnit para que os testes fossem executados. Era necessário extender uma das classes de Test Case do JUnit, e seus métodos precisavam seguir um padrão de nome especÃfico definido pelo framework.
Com a versão 4.* e a introdução ao suporte a Java 5, agora todas as configurações de testes unitários em JUnit são feitas via anotações, o que na minha opinião é muito mais rápido e fácil, tornando muito mais agradável e flexÃvel escrever testes unitários. Agora é possÃvel definir umahierarquia especÃfica para os testes do projeto, podendo abstrair muitas inicializações e padrões do sistema, facilitando o reaproveitamento e aumentando a velocidade de desenvolvimento. Afinal a maior parte do tempo gasto em desenvolvimento é com os testes.
Porém, com anotações, perdemos o acesso direto aos métodos de asserção de valores que as super classes definiam. A solução adotada foi tornar todos esses métodos estáticos e públicos, em uma classe especÃfica para guardá-los: org.junit.Assert.
Pode parecer uma solução não muito elegante do ponto de vista de código, e de fato não é quando consideramos código que será distribuÃdo e deploiado, porém é uma solução que faz total sentido no escopo dos testes unitários, tornando fácil o uso e acesso a tais funcionalidades.
Asserções
Para testar nosso código, o JUnit fornece os métodos de assert. O conceito é muito simples, todo método de asserção recebe um valor que é o correto esperado pelo teste, e o outro valor que é o devolvido pelo seu código. A comparação é executada, e o teste falha caso sejam diferentes e passa caso sejam iguais. Apenas com esse conceito é possÃvel testar todo o código, basta saber quais são os valores que devem ser testados para garantir o funcionamento do código.
A chave para escrever um teste unitário que cobre muito bem o seu código, é colocar as asserções nos valores realmente relevantes ao funcionamento do sistema. Algumas vezes por exemplo, não é preciso testar um valor intermediário gerado pelo código, apenas o resultado final, outras vezes esse valor intermediário gerado é crucial para o resultado final, e portanto deve ser verificado também.
Quando eu menciono ‘valores’, entenda que um valor pode ser qualquer objeto Java, portanto é muito importante implementar o equals e hashcode de seus objetos de resposta que serão testados pelo JUnit.
Exemplo Prático
Vamos criar um exemplo de classe de testes com o JUnit 4 para vermos como funciona na prática a execução de testes unitários.
Se você utiliza o Eclipse, você já possui instalado o plugin de execução de testes do JUnit, caso você não tenha tal plugin, recomendo que instale posi facilita muito a execução e depuração dos testes.
Vamos criar uma classe de testes:
|
1
2 3 |
public class JUnitTestCase
|
Repare que apesar do nome parecer que segue algum padrão, não é necessário que a classe tenha nenhuma dessas palavras em seu nome. Porém esta classe ainda não é uma classe de testes do JUnit. Para torná-la um teste, crie um método da seguinte forma:
|
1
2 3 4 |
@Test
public void metodoQualquer()
|
Repare na anotação org.junit.Test. Essa anotação diz que nosso método ‘metodoQualquer’ é um teste do JUnit. Perceba também que seu retorno é ‘void’ e ele não recebe nenhum argumento. Agora nossa classe é um teste propriamente dito. Simples assim. Vamos adicionar uma asserção agora para ver o funcionamento da mesma. Dentro do método que acabamos de criar, adicione a seguinte chamada:
|
1
|
Assert.assertEquals(“2 dividido por 2 deveria ser 1.”, 1, 2 / 2);
|
Repare que o primeiro argumento do método, é a mensagem que vai aparecer caso o método falhe. Mude o valor obtido (último argumento) para ver a mensagem de erro.
Esse é o básico de execução de testes. Por mais simples que possa parecer, esse é o ponto de partida. Agora existem outras funcionalidades qua ajudam a escrever testes mais complexos, por exemplo, se precisarmos criar um objeto mais complexo para nossos testes, fazemos o seguinte, adicione o seguinte código em nossa classe de testes:
|
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
private String stringLocal;
@Before @Test @Test @After |
Rode o teste e veja o que aparece no console.
Repare que a String é inicializada e setada novamente pra ‘null’ 3 vezes. Isso porque nossa classe possui 3 métodos de testes, e os métodosanotados com @Before rodam sempre antes de todos os métodos de teste. O mesmo vale para os métodos anotados com @After, só que estes rodam depois de executar os métodos de teste.
Só com essas duas anotações é possÃvel criar cenários que estão sempre ‘zerados’ e corretamente incializados para cada teste que será executado em sua classe. Perceba que com isso é possÃvel separa melhor as asserções em suas classes em mais métodos, deixando mais especÃfico e focado cada método de teste.
Porém algumas vezes queremos inicializar algum objeto para o teste todo, sem precisar de algo especÃfico para cada execução. Nesse caso existem duas outras anotações que podem ser úteis. Adicione o seguinte trecho em nossa classe de testes:
|
1
2 3 4 5 6 7 8 9 |
Só existe um restrição com essa abordagem, e acho que está claro no código qual que é: o escopo dessas chamadas é estático. Repare que os métodos precisam ser estáticos, e portanto as incializações só servirão para propriedades que são estáticas em sua classe de testes.
Essa funcionalidade possui esse comportamento porque o JUnit instancia um novo objeto da sua classe de testes para cada método que será rodado, dessa forma ele garante um melhor isolamento dos testes, tornando-os mais unitários por assim dizer. Dessa forma somente métodos estáticos são garantia de execução antes de todos os outros métodos.
Rode o teste e veja a ordem das mensagens em seu console.
Próximos passos
Essa foi uma introdução muito simples do JUnit e testes unitários. Acho que já passou pela sua cabeça muitas formas de inicializar, integrar e rodar testes em sua aplicação usando JUnit, o que é ótimo, mas ainda existem boas práticas para criar testes assim como existem boas práticas para escrever código, afinal testes são linhas de código também.
O segredo de um bom teste unitário é o quanto ele consegue cobrir do funcionamento do código, sem que seja necessário escrever um teste extremamente detalhado que deixe o código acoplado demais, e não permita muita mudança no código original. Se você investir tempo demais testando TODOS os valores possÃveis de suas classes de maneira extremamente detalhada, quando o cliente pedir que um requisito mude, você com certeza vai ter a sensação de trabalho jogado fora, e desânimo por ter que escrever tudo novamente. A idéia é utilizar padrões de design para testes unitários, de forma que se mantenha a cobertura de código no 85%+ e ainda deixe os testes bem flexÃveis a mudança. DifÃcil mas não impossÃvel, e sim, é muito mais difÃcil e trabalhosos escrever testes realmente bons, do que escrever o código que será testado.
Por @Gust4v0_H4xx0r
Mudanças para 2012

2012 será mais um ano de ascensão dos dispositivos mobile em todo o mundo. Mesmo que aqui no Brasil tudo seja mais lento, com preços mais altos, estamos seguindo em frente. Já temos frameworks javascript adaptados ? s telinhas, como o Sencha, ? e o jQueryMobile, além do Flex Mobile, claro. Outras tecnologias estão crescendo a cada dia, e a quantidade de informação que é “jogada” para nós programadores aumenta em um ritmo alucinante. Seguindo esta tendência, estamos também nos adaptando, e para que tudo fique bem claro ao leitor, decidi comentar as principais mudanças do site neste post.
Neste novo ano estaremos adotando algumas mudanças que visam melhorar a qualidade de nossas obras. As principais mudanças que estão por vir são:
1)? Fim do suporte por email: Nestes quatro anos de suporte por email, pude observar diversos prós e contras, e sempre tentei agradar a “gregos e troianos”. Nunca fiz nenhuma distinção de quem comprou ou quem não comprou meus livros, sempre respondendo as dúvidas em menos de 48 horas. Todo esse tempo foi um aprendizado enorme, e agora tenho a necessidade de “lapidar” este processo de suporte. Observei que muito das dúvidas dos leitores eram repetidas e que sempre respondia ? s mesmas questões. Observei também que, ? s vezes, dava prioridade a alguém que não tinha comprado um livro, e deixava “na fila” uma outra pessoa que tinha dúvidas relativas aos livros. Também cheguei ao ponto de responder 10, 15 e-mails por dia, tornando uma tarefa bastante trabalhosa. Neste contexto, estarei “movendo” o suporte para um fórum especial, aberto a qualquer pessoa e destinado a sanar dúvidas dos livros. Falarei mais deste fórum em um outro post, mas deixo claro que, para quem é leitor, terá como sempre o suporte 100% garantido.
2)? eBOOKs serão predominantes: Todo o processo de criação/distribuição de um ebook é perfeito aos olhos do autor se não fosse a pirataria. Realmente encontrar meus livros que consumiram várias horas de preparo e trabalho nos torrents por aà não é uma sensação boa. Mas eu quero acreditar que isso é possÃvel! Eu quero acreditar que o brasileiro é gente honesta, que deseja pagar por um conteúdo útil sem ser “assaltado”. Por isso, em 2012, eu vou priorizar o desenvolvimento de eBooks, cobrando um preço justo, e com a meta de criar muito mais ebooks do que já foi criado atualmente.
3)? Flex não será prioridade: Nestes últimos quatro anos tenho me dedicado muito ao Flex. Fui o primeiro a escrever um livro sobre Adobe Flex no Brasil e desde então foram quase 10 livros abordando o tema. Sei que está chegando o momento em que eu terei que “dissipar” o meu conhecimento para outras áreas, pois o tema Flex já está bastante difundido, felizmente hoje em dia existe bastante conteúdo dedicado a cultura Flex e só não aprende quem não quer. Veja que, para quem escreve livros, as tecnologias saturam, mas não morrem. Este é o caso do Flex, o conteúdo está saturado, eu não tenho muito mais a escrever, por isso o foco será distribuÃdo para outras áreas. O livro “Adobe Air em Ação” será o último livro a ser escrito para a tecnologia Flex, e não haverá mais edições previstas. O suporte continuará normalmente para quem comprou qualquer livro sobre Flex.
4)? Mobile será prioridade: Daremos certa prioridade ao desenvolvimento mobile, e dependendo de novas tecnologias que deverão surgir, estaremos pesquisando e publicando material sobre elas. Isso significa que determinados livros poderão conter menos páginas, por exemplo, 100, mas que expliquem um conceito ou tecnologia emergente.
5)? Tendências serão prioridade:? A rapidez com que uma tecnologia emerge abre uma lacuna de desinformação para nós tupiniquins. E a? idéia? é preencher esta lacuna com um livro. Por exemplo, ainda não temos um livro sobre SENSHA, muito menos EXTJS. Um livro sobre HTML 5, custa nada mais, nada menos que 73 reais. Nem temos um livro sobre a linguagem SCALA ou sobre DJANGO. Enfim, existe muito assunto para se escrever.
6)? Site flex.etc.br deixa de conter informações sobre os livros:? Todas as informações estarão no site danielschmitz.com.br. O blog flex continua, mas aos poucos deixará de ser atualizado.
Resumindo:
- Vamos publicar ebooks com qualidade e a preços atraentes, sobre diversos temas. Contamos com a aprovação de vocês, enviando crÃticas e sugestões, .
- Haverá um fórum dedicado ao suporte dos livros.
- Estaremos em breve publicando quais serão os primeiros eBooks a serem lançados e contamos com a sua opinião. Mande ideias !





