Abr 16

Download: Cartilha de eCommerce como se tornar um eVarejista

Escrito por Igor Musardo em .NET, 1, 2.0, 4, AR, BI, C#, class, consultoria, Curso, Cursos, Desenvolvimento, Download, economia, for, game, git, IE, image, int, internet, Livro, Mercado, mg, O, on, on-line, pagamento, RIA, Ria’s Geral, S+S, sociedade, TAT, UI, uint, varejo @ 04 16th, 2012 | via http://www.igormusardo.com.br | Sem comentários

A C?mara Brasileira de Com?rcia Eletr?nico, Camara-e.net, fundada em 07 de maio de 2001, ? a principal entidade multissetorial da Am?rica Latina e entidade brasileira de maior representatividade da Economia Digital. O seu papel tem sido fundamental para a promo??o da seguran?a nas transa??es eletr?nicas, a formula??o de pol?ticas p?blicas alinhadas aos anseios da sociedade moderna e, especialmente, para o aprimoramento de marcos regulat?rios setoriais que d?o suporte legal ?s medidas de incentivo necess?rias ao desenvolvimento de nosso pa?s.

O Comit? Meios de Pagamento na Internet da Camara-e.net disponibilizou uma cartilha completa para varejistas que desejam dar os primeiros passos no mercado de eCommerce e se tornar um eVarejista.

A cartilha possui o seguintes m?dulos:

Com?rcio Eletr?nico: Uma Grande Oportunidade de Neg?cios;
Estrutura e Recursos de uma Loja de Varejo On-Line;
Suporte ? administra??o da Loja de Varejo On-line.

Fa?a o download da Cartilha de eCommerce eVarejista e tenha bons estudos.

Se precisar de ajuda para criar sua loja virtual e aumentar suas vendas contrate minha Consultoria de Intelig?ncia para eCommece.

Jan 3

SharedObject com Flash Media Server

Escrito por Leonardo França em .NET, 1, 2.0, 4, 6, action, Actionscript, ActionScript 3, Actionscript 3.0, Actionscript3, Adobe, Air, Aplicativos, app, AR, BI, botão, browser, C#, class, cliente, código, Cookie, Curso, dados, demo, Download, err, event, EventListener, events, exemplo, Ferramenta, filter, flash, flash media, Flash Media Server, Flash Player, Flex, FMS, function, Geral, git, Google, handle, html, ide, IE, if, image, instalação, int, live, mg, O, on, Outros, Partilha, player, pt, referencia, RIA, Ria’s Geral, RTM, RTMP, S+S, server, servidor, swf, TAT, UI, uint, update, Ved, web, window @ 01 3rd, 2012 | via http://www.leonardofranca.com.br | Sem comentários

SharedObject é um recurso que dar ao Flash Player a capacidade de salvar dados localmente para poder ser usado posteriormente em sua aplicação, a grosso modo é como um cookie. Com o Flash Media Server, foi introduzido a possibilidade de usar o SharedObject Remote, no qual os dados são salvos no servidor Flash Media Server e compartilhados para todas as instâncias de uma conexão entre o Flash Player e o Flash Media Server. Isso possibilita a criação de aplicativos em real time como Dashboards, chats e o que mais a imaginação permitir.

O uso do SharedObject Remote pode ser usado de duas maneiras em conjunto com o Adobe Flash Media Server.

Somente pelo lado cliente, através do Flash Player/AIR
Em conjunto com ActionScript Communication, linguagem de servidor do Flash Media Server

Vejamos o primeiro caso:

Através do lado cliente, através do Flash Player/AIR

Caso você não tenha conhecimento para usar a linguagem Server-side do Flash Media Server, é possível utilizar o SharedObject Remote somente pelo ActionScript 3.0. Vamos a um exemplo clássico sharedBall, onde o objetivo é compartilhar as posições da bolinha a atualizar nos outros clientes conectados a mesma instância.

Vá até o diretório de instalação do Flash Media Server e procure pela pasta “applications”, lá crie um diretório chamado “sharedBall”, dentro dele um arquivo chamado “main.asc”
Abra o main.asc no seu editor de textos de preferencia ou pelo próprio Flash e digite: trace(“sharedBall…”);
Vamos testar esse arquivo, abra o console do Flash Media Server, geralmente fica localizado no diretorio de instalação/webrrot/swfs. Você pode abrir pelo browser ou o swf diretamente.
Clique no botão “View Applications” e em seguida procure o nome “sharedBall” no combobox logo no canto inferior esquerdo onde está escrito “New Instance…”
Selecione “sharedBall” e deveremos ter na aba Live Log algo como na imagem abaixo:

No Flash, criei uma bola com as ferramentas de desenho e converti para MovieClip dando o nome de “mc_ball”.
Estamos prontos para começar a integração entre o Flash e o Flash Media Server. Crie um layer para o ActionScript e abra o editor apertando F9 ou “Window->Actions”
Nosso código começa com a conexão com o servidor Flash Media Server

PLAIN TEXT

ACTIONSCRIPT3:

import flash.net.NetConnection;
import flash.events.NetStatusEvent;
var nc:NetConnection;
function init():void
nc = new NetConnection();
nc.addEventListener(NetStatusEvent.NET_STATUS, handlerNetStatus);
nc.connect(“rtmp://localhost/sharedBall”);
function handlerNetStatus(evt:NetStatusEvent):void
trace(evt.info.code);
init();

Feito isso, podemos testar o swf apertando Ctrl+Enter, se tudo correr bem, deveremos ter a seguinte mensagem no output do Flash:

NetConnection.Connect.Success

Com a conexão feita, podemos instanciar o nosso SharedObject Remote para compartilhar as posições de x e y da bolinha.

PLAIN TEXT

ACTIONSCRIPT3:

if(evt.info.code == “NetConnection.Connect.Success”)
so = SharedObject.getRemote(“so”,nc.uri,false);
so.addEventListener(NetStatusEvent.NET_STATUS, handlerNetStatus);
so.addEventListener(SyncEvent.SYNC, handlerSync);
so.connect(nc);

O handlerSync é responsável por atualizar os dados de x e y pegaremos do SharedObject Remote:

PLAIN TEXT

ACTIONSCRIPT3:

function handlerSync(evt:SyncEvent):void
mc_ball.x = so.data.x;
mc_ball.y = so.data.y;

Daremos a opção de ao clicar na bolinha, que ela possa ser arrastável, em seguida atualizaremos as posições de x e y no SharedObject Remote:

PLAIN TEXT

ACTIONSCRIPT3:

mc_ball.addEventListener(MouseEvent.MOUSE_DOWN, handlerSharedBall);
mc_ball.addEventListener(MouseEvent.MOUSE_UP, handlerSharedBallOut);
function handlerSharedBall(evt:MouseEvent):void
this.addEventListener(Event.ENTER_FRAME, update);
mc_ball.startDrag();
function handlerSharedBallOut(evt:MouseEvent):void
mc_ball.stopDrag();
function update(evt:Event=null):void
so.setProperty(“x”,mc_ball.x);
so.setProperty(“y”,mc_ball.y);

Segue o código completo:

PLAIN TEXT

ACTIONSCRIPT3:

import flash.net.NetConnection;
import flash.events.NetStatusEvent;
import flash.net.SharedObject;
import flash.events.SyncEvent;
import flash.events.MouseEvent;
import flash.events.Event;
var nc:NetConnection;
var so:SharedObject;
function init():void
nc = new NetConnection();
nc.addEventListener(NetStatusEvent.NET_STATUS, handlerNetStatus);
nc.connect(“rtmp://localhost/sharedBall”);
function handlerNetStatus(evt:NetStatusEvent):void
{
trace(evt.info.code);
if(evt.info.code == “NetConnection.Connect.Success”)
so = SharedObject.getRemote(“so”,nc.uri,false);
so.addEventListener(NetStatusEvent.NET_STATUS, handlerNetStatus);
so.addEventListener(SyncEvent.SYNC, handlerSync);
so.connect(nc);
}
function handlerSync(evt:SyncEvent):void
mc_ball.x = so.data.x;
mc_ball.y = so.data.y;
mc_ball.addEventListener(MouseEvent.MOUSE_DOWN, handlerSharedBall);
mc_ball.addEventListener(MouseEvent.MOUSE_UP, handlerSharedBallOut);
function handlerSharedBall(evt:MouseEvent):void
this.addEventListener(Event.ENTER_FRAME, update);
mc_ball.startDrag();
function handlerSharedBallOut(evt:MouseEvent):void
mc_ball.stopDrag();
function update(evt:Event=null):void
so.setProperty(“x”,mc_ball.x);
so.setProperty(“y”,mc_ball.y);
init();

Veja uma demostração em funcionamento:

Download sharedBall

Dez 14

Testes Unitários com JUnit – De volta ao básico

Escrito por DClick Team em 1, 2.0, 4, 6, Air, AR, arte, C#, case, class, classe, classes, cliente, código, comparação, demo, Desenvolvimento, Design, Download, Eclipse, err, erro, exemplo, falha, Ferramenta, Flex, for, framework, Google, ide, IE, if, int, Introdução, Java, NaN, O, on, Opinião, Outros, padrão, Plugin, print, rest, RIA, Ria’s Geral, S+S, Sem categoria, site, string, Sun, super(), TAT, Tema, Teste, Twitter, UI, uint @ 12 14th, 2011 | via http://blog.dclick.com.br/pt/ | Sem comentários

Twitter!

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
public void inicializaLocal()
System.out.println(“Inicializou.”);
this.stringLocal = “inicializada”;

@Test
public void testInicializadaLocal1()
Assert.assertEquals(“A String deveria estar inicializada.”, “inicializada”,
this.stringLocal);

@Test
public void testInicializadaLocal2()
Assert.assertEquals(“A String deveria estar inicializada.”, “inicializada”,
this.stringLocal);

@After
public void setaNull()
System.out.println(“Setou nulo.”);
this.stringLocal = null;

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

@BeforeClass
public static void antesDeTudo()
System.out.println(“Executado Antes.”);

@AfterClass
public static void depoisDeTudo()
System.out.println(“Executado Depois.”);

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

Dez 5

Play Framework – alta produtividade em Java

Escrito por Erko Bridee em .NET, 1, 2.0, 4, 6, action, Adobe, Adobe Flex, apache, api, AR, Arquitetura, BI, blog, browser, C#, case, class, cliente, Componente, Componentes, control, Controles, CRUD, css, Curso, Cursos, dados, Desenvolvedor, desenvolvedores, Desenvolvimento, Desktop, Dica, Download, Eclipse, email, engine, err, erro, exemplo, Exemplos, Flex, Flexmania, for, framework, Frameworks, gae, Geral, git, Google, Hibernate, html, ide, IE, if, image, imagens, int, internet, Java, JPA, Links, mg, mvc, novidade, Novidades, O, on, Outros, produtividade, rails, rest, RIA, Ria’s Geral, ruby, ruby on rails, S+S, server, servidor, site, state, tag, TAT, Tema, template, Teste, Tree, Tutorial, UI, UX, Ved, web, Web Service, XML, XP @ 12 5th, 2011 | via http://blog.erkobridee.com | Sem comentários

O Play ? um framework open source para aplica??es web, escrito em Java, que possibilita o desenvolvimento de aplica??es web que seguem o padr?o MVC. Tem por objetivo otimizar a produtividade do desenvolvedor atrav?s do uso de configura??o sobre conven??o (CoC). Com recompila??o feita durante a execu??o da aplica??o, e caso ocorra algum erro, o respectivo ? exibido no browser, indicando a linha do erro.

Aten??o: o objetivo desse post ? realizar uma vis?o geral do que se trat? o Play Framework que temos ouvidos os coment?rios na internet.

O Play Framework torna o desenvolvimento de aplica??es Java e Scala uma tarefa f?cil para o desenvolvedor.

Site: Play Framework

Descubra uma alternativa limpa e leve para as atuais aplica??es Java Enterprise. O Play ? focado na produtividade do desenvolvedor e tem por alvo a arquitetura RESTFul.

Apesar do Play ter sido escrito em Java, ele suporta a linguagem Scala desde a vers?o 1.1 (hoje[Dezembro/2011] est? na vers?o 1.2.4). Este ano a empresa Typesafe (respons?vel pela linguagem Scala), anunciou a aquisi??o do Play Framework e este ser? mantido pela empresa. Uma das novidades relacionado a este anuncio ? que a vers?o 2.0 o n?cleo do Play Framework est? sendo totalmente reescrito em Scala.

Um v?deo para uma breve apresenta??o do Play Framework: Desenvolcendo uma aplica??o web em 10 minutos

Motiva??o

O Play foi muito inspirado no Ruby on Rails e Django. Um desenvolvedor familiarizado com qualquer um desses 2, ir? se sentir em casa.

Algo que ? fato, Ruby on Rails e Django s?o produtivos, ent?o por que n?o ter o mesmo n?vel de produtividade com java?

O Play utiliza do poder das aplica??es Java, por?m sem o “sofrimento” necess?rio para o desenvolvimento de aplica??es centradas no modelo Java Enterprise. Libertando das metodologias e ideologias relacionadas ao desenvolvimento de aplica??es Java EE, o Play prove para os desenvolvedores uma maneira f?cil e elegante de trabalhar, visando o aumento da produtividade.

Caso voc? queria, basta um editor de c?digo e ser? mais que o suficiente para o desenvolvimento de aplica??es, chega a ser incr?vel pensar que conseguiremos desenvolver aplica??es Java Web sem a necessidade de um IDE (Eclipse, Netbeans, …), mas vale lembrar, que estas IDE's ainda possuem seus atrat?vos e auxiliam em nossa produtividade.

Apesar de que as aplica??es desenvolvidas com o Play, foram projetadas para executar dentro do JBoss Netty Web Server, as aplica??es podem ser empacotadas em arquivos WAR e distribu?das para outros servidores de aplica??es Java EE (ex.: Apache Tomcat).

Maiores diferen?as com os demais frameworks

Stateless: o Play ? totalmente RESTful – n?o existe conex?o por sess?o Java EE. Isto torna o Play muito mais escal?vel que os demais frameworks.

Sem configura??o: realizar o download, descompactar e desenvolver.

F?cil ida e volta: sem necessidade de deploy no servidor de aplica??o, apenas edite o c?digo e atualize o browser.

Teste unit?rio integrado: suportes nativos para JUnit e Selenium.

API elegante: raramente um desenvolvedor ter? a necessidade de importar alguma lib. O Play j? disponibiliza a maioria dos recursos necess?rios para o desenvolvimento de uma aplica??o.

M?todos est?ticos: todos os controles de entrada e m?todos de neg?cio s?o declarados como est?ticos. E isto ? de fato bem diferente o que vemos nos demais frameworks Java.

I/O Ass?ncrona: atrav?s do uso do servidor web JBoss Netty, o Play consegue disponibilizar e tratar uma enorme quantidade de requisi??es ass?ncronas.

Arquitetura Modular: assim como Rail e Django, o Play utiliza o conceito de m?dulos. O que possibilida um meio elegante e simples de expandir o core do Play.

M?dulo CRUD: f?cil constru??o de UI administrativas com pouco c?digo.

M?dulo Scala: disponibiliza um suporte completo para Scala.

Componentes

O Play utiliza massivamente algumas bibliotecas populares:

JBoss Netty para o servidor web.
Hibernate para a camada de dados.
Groovy para a os templates.
O compilador do Eclipse para atualiza??o da aplica??o sem necessidade de realizar um deploy da aplica??o para testar as altera??es (hot-reloading).
Apache Ivy para gerencimanto de dependencias.

Funcionalidades presentes no n?cleo do Play:

Um framework RESTful limpo e leve.
CRUD: um m?dulo para simplicifar a edi??o de modelos de objetos.
Secure: um m?dulo para habilitar um sistema de autentifica??o de usu?rios.
Um framework de valida??o baseado em anota??es.
Um Job Scheduler (agendamento de tarefas).
Suporte para emails SMTP de maneira simples.
Suporte para JSON e XML.
Uma camada de persist?ncia baseada em JPA.
Uma base de dados embutida para r?pido deploy e testes da aplica??o.
Um framework completo para realiza??o de testes.
Funcionalidade para upload de arquivos.
Suporte para m?ltiplos ambientes de desenvolvimento.
Uma poderosa engine de templates baseadas em Groovy com templates, hierarquias e tags.
Arquitetura modular, que possibilita criar novas funcionalidades para o n?cleo facilmente.
Suporte para OpenID e clientes de Web Service.

Links ?teis

Informa??es a mais da Wikipedia

Overview do Play Framework 1.2.4

Documenta??o Play Framework 1.2.4

A documenta??o foi algo que achei interessante, me parece bem completa com bastante exemplos e informa??es de como utilizar as funcionalidades presentes no Play Framework.

Suporte para a linguagem Scala

Utilize a IDE de sua prefer?ncia (Eclipse, Netbeans, …)

Se por um acaso voc? utilize o Sublime Text 2, veja esse suporte para este editor de c?digo [github]

Reposit?rio de M?dulos

Dentre eles temos: MongoDB, GAE, Gera??o de PDF, GWT, SASS e SCSS, entre outros.

E agora?

Bom agora que j? temos uma boa id?ia do que se trata o Play Framework ? baixar e come?ar a testar e ver se na pr?tica ele ? bom mesmo.

Hora de fazer o download, instalar e colocar a m?o no c?digo: Tutorial para seguir e ver uma aplica??o do in?cio at? o “fim”

Eu particularmente ainda possuo algumas quest?es em aberto para descobrir as respostas, dentre elas est? uma: - Como ? que eu utilizo o Play Framework em um projeto com uma equipe? At? o momento s? tenho visto casos onde s?o apresentados desenvolvimetno de aplica??es r?pidas, por?m com um ?nico desenvolvedor…

No meu caso eu vou atr?s dessa reposta.

Veja também:

Dez 5

Flex Patch de segurança

Escrito por SamuelFacchinello em 1, 4, 6, Adobe, AR, BI, blog, Blogs, C#, dados, Download, Flex, for, Google, html, Links, mg, O, on, pt, Ria’s Geral, S+S, SDK, site, UI @ 12 5th, 2011 | via http://desenvolvendoemflex.blogspot.com/ | Sem comentários

Devido a uma vulnerabilidade no SDK do Flex, muitas aplicações estão vulneráveis ??a cross-site scripting (XSS), e deve ser corrigida, a fim de proteger os dados do usuário.

Os links para download do patch são:

Mais informações aqui.

Nov 8

Spring 3.1 RC1 – Cache Abstraction

Escrito por DClick Team em 1, 2.0, 4, 6, action, app, AR, Arquitetura, Banco de Dados, BI, blog, C#, cache, class, classe, configuração, dados, Documentação, Download, err, erro, exemplo, for, framework, Google, html, ide, IE, if, int, interface, Java, lite, map, mapa, O, on, Outros, padrão, pt, reference, RIA, Ria’s Geral, S+S, Sem categoria, site, Spring, Spring Framework, SpringFramework, string, Sun, tag, TAT, Teste, Twitter, UI, uint, XML, zend @ 11 8th, 2011 | via http://blog.dclick.com.br/pt/ | Sem comentários

Twitter!

Spring Cache Abstraction

Abordamos um das novas funcionalidades do Spring 3.1 RC1, profiles e environments. Ainda existem outras funcionalidades, mas hoje iremos dar uma olhada em Cache Abstraction.

Cache Abstraction é literalmente uma abstração out of the box para adicionar uma camada de cache sobre seus beans, usando uma arquitetura AOP para gerenciar o que deve e o que não deve ser feito o cache.
Usar a nova camada de cache é muito fácil se você já está habituado com Spring, e veremos uma das diferentes maneiras de configurar seus beans.

Baixando a Denpendência

Para quem utiliza maven, basta adicionar a seguinte dependência no pom do seu projeto:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

>
>
>org.springframework.maven.milestone>
>Spring Maven Milestone Repository>
>http://maven.springframework.org/milestone>
>
>

>
>
>org.springframework>
>spring-core>
>3.1.0.RC1>
>
>
>org.springframework>
>spring-context>
>3.1.0.RC1>
>
>

Se você perferir, pode baixar os jar direto do site do spring.
Sem segredos aqui, basta adicionar as dependências ao projeto e está pronto para usar.

Entendendo o funcionamento

A maneira com que o cache funciona é bem simples. Você pode enxergar o cache como um mapa chave-valor, onde a chave é o conjunto de argumentos do seu método, e o valor é o valor devolvido pelo seu método. Pensando assim fica fácil entender o funcionamento que irei mostrar no exemplo.
Referente a configuração do Spring, é necessário instanciar um gerenciador de cache, ou na linguagem spring, cacheManager. Existe algumas implementações de cache manager disponível no spring, portanto iremos utilizar uma delas em nosso exemplo.
Vamos escrever um teste unitário com JUnit 4.8.1 para ilustrar o comportamento do cache.
Comece criando um arquivo padrão de beans do spring, mas com um namespace a mais:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

>
Repare que estamos utilizando o namespace de cache além dos usuais.
A única configuração que iremos fazer aqui, é a do cache manager. Crie um bean da classe >SimpleCacheManager> e adicione o seguinte bean como cache gerenciado:
>
cc lang=”XML”
public interface CacheableTest

@CacheEvict(value = “property”, allEntries = true)
void evictCache();

@Cacheable(“property”)
String getForCache(String s);

String getProperty();

void setProperty(String property);

Repare no getter e setter que usaremos no teste, e na anotação @Cacheable(“property”). Esta anotação está dizendo que o valor que este método devolver será armazenado no cache que configuramos previamente como property. Fato importante é que este valor é referente ao argumento passado como parâmetro no método.
A outra anotação @CacheEvict(value = “property”, allEntries = true) descreve o método que chamaremos para esvaziar o cache. Note que passamos o nome do cache, e que ele deve limpar todos os valores.
É importante notar também que pode ser passado mais de um nome de cache em ambas as anotações.
Uma implementação básica para nosso bean pode ser:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

@Component(“cacheBean”)
public class CacheableBean implements CacheableTest

private String property;

public String getForCache(String s)
return this.property;

public String getProperty()
return property;

public void setProperty(String property)
this.property = property;

public void evictCache()
// Não faz nada

}

Estou usando o package scan para instanciar o bean. Agora nosso teste:

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
26
27
28
29
30
31
32
33
34

public class CacheTest

@Test
public void testCache()

ApplicationContext ctx = new ClassPathXmlApplicationContext(
“spring31-test-beans.xml”);

CacheableTest bean = ctx.getBean(“cacheBean”, CacheableTest.class);

bean.setProperty(“teste”);

Assert.assertEquals(“teste”, bean.getProperty());
Assert.assertEquals(“teste”, bean.getForCache(“a”));

bean.setProperty(“teste2″);
Assert.assertEquals(“teste2″, bean.getProperty());
Assert.assertEquals(“teste”, bean.getForCache(“a”));
Assert.assertEquals(“teste2″, bean.getForCache(“b”));

bean.setProperty(“teste3″);
Assert.assertEquals(“teste3″, bean.getProperty());
Assert.assertEquals(“teste”, bean.getForCache(“a”));
Assert.assertEquals(“teste2″, bean.getForCache(“b”));

bean.evictCache();
bean.setProperty(“teste4″);
Assert.assertEquals(“teste4″, bean.getProperty());
Assert.assertEquals(“teste4″, bean.getForCache(“a”));
Assert.assertEquals(“teste4″, bean.getForCache(“b”));

}

O arquivo de beans se chama spring31-test-beans.xml.
Repare que estamos invocando o método getForCache passando alguns valores diferentes, e o valor devolvido é sempre igual, mesmo que depois setamos um valor diferente ao bean. Para atualizar o valor e limpar o cache, basta invocar o método evictCache que havíamos anotado com @CacheEvict.
Vale a pena brincar um pouco com o funcionamento do cache, e até mesmo criar outros caches e ver o comportamento do evict em diferentes métodos.

Últimas Considerações

As mesmas configurações que fizemos com anotações, pode-se fazer direto no XML. Não entrarei no detalhe pois o funcionamento é exatamente o mesmo, mas se você preferir basta olhar a documentação que é bem straightforward.
Lembre-se que esta camada de cache não possui nenhuma relação com o banco de dados, e deve ser usada com muito cuidado em tais casos, pois alguns erros de concistência podem aparecer devido a um cache desatualizado.
Vale a pena brincar com o cache manager, pois o spring suporta o uso do EhCache, o que pode ser muito útil se você já possui alguma configuração pré-definida para sua aplicação.

Por enquanto é isso, qualquer dúvida mande nos comentários que responderei assim que possível.

Por @Gust4v0_H4xx0r

Nov 4

Spring 3.1 RC1 – Profiles

Escrito por DClick Team em 1, 2.0, 4, 6, Air, app, AR, Banco de Dados, bar, BI, C#, carregar, class, código, dados, demo, Desenvolvimento, Dica, dispatch, Download, err, exemplo, for, framework, Google, ide, IE, if, int, interface, Java, LOB, lógica, novidade, Novidades, O, on, Outros, override, refresh, Release Candidate, RIA, Ria’s Geral, S+S, Sem categoria, site, Spring, SpringFramework, string, Sun, TAT, Teste, Twitter, UI, uint, web, XML, zend @ 11 4th, 2011 | via http://blog.dclick.com.br/pt/ | Sem comentários

Twitter!

Profiles e Environments no novo Spring 3.1

A SrpingSource adotou a estratégia de soltar mais versões do Spring com mais velocidade e escopos de funcionalidades menores.
Seguindo tal estratégia acabou de sair do forno o primeiro release candidate da versão 3.1 do framework.
Para uma estratégia de escopos menores, até que tiveram bastante trabalho e adicionaram várias novidades. Vamos cobrir as novidades aos poucos, começando com uma muito interessante: Profiles e Environments.

Especificando Profiles nos Beans

A idéia de um profile é simples. Um profile define um escopo, envirnmente como é chamado no framework, em que certos beans estarão disponíveis e outros não.
Imagine que você precisa de uma conexão com o banco de dados de testes, que é diferente do banco de dados de desenvolvimento. Com profiles podemos definir um data source do profile de desenvolvimento, e outro do profile de testes, instanciando o correto de acordo com o ambiente que a aplicação irá rodar.

Anotações

Para especificar um profile no seu bean, basta adicionar a anotação @Profile com o nome do profile correspondente. Lembrando que este é o caso em que seus Beans estão sendo criados pelo component-scan usando package scan. Vamos criar um exemplo pra ficar mais claro o que acontece.
Vamos criar uma interface comum para nossos beans:

1
2
3
4
5

public interface ProfileEspecificBean

String recoverActiveProfile();

Agora vamos criar dois profiles e dois beans diferentes para a mesma interface. Um é o bean de desenvolvimento (dev) e o outro de testes (qa).

1
2
3
4
5
6
7
8
9
10

public final class Profiles

private Profiles()

public static final String DEV_PROFILE = “dev”;

public static final String QA_PROFILE = “qa”;

}

1
2
3
4
5
6
7
8
9
10
11
12

package br.com.dclick.tentativas.beans;

@Component(“profileBean”)
@Profile(DEV_PROFILE)
public class DevEspecificBean implements ProfileEspecificBean

@Override
public String recoverActiveProfile()
return DEV_PROFILE;

}

1
2
3
4
5
6
7
8
9
10
11
12

package br.com.dclick.tentativas.beans;

@Component(“profileBean”)
@Profile(QA_PROFILE)
public class QAEspecificBean implements ProfileEspecificBean

@Override
public String recoverActiveProfile()
return QA_PROFILE;

}

Repare que já anotei os beans com @Profile respeitando os profiles específicos de cada bean.
Agora criamos o arquivo de beans do spring, dei o nome de spring31-test-beans.xml:

1
2
3
4
5
6
7
8
9
10
11

<?xml version=“1.0″ encoding=“UTF-8″?>
xmlns=“http://www.springframework.org/schema/beans”
xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance” xmlns:context=“http://www.springframework.org/schema/context”
xsi:schemaLocation=“http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.1.xsd”>

:component-scan base-package=“br.com.dclick.tentativas.beans” />

Feito isso, vamos criar um teste para verificar a lógica de criação dos beans. estou usando JUnit 4.8.1.

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
26
27
28
29
30
31
32

public class ProfileBeansTest

@Test
public void testProfileDev()

GenericXmlApplicationContext ctx = new GenericXmlApplicationContext();
ctx.getEnvironment().setActiveProfiles(DEV_PROFILE);
ctx.load(“classpath:spring31-test-beans.xml”);
ctx.refresh();

// Profile de DEV
ProfileEspecificBean profileBean = ctx.getBean(“profileBean”,
ProfileEspecificBean.class);

Assert.assertEquals(DEV_PROFILE, profileBean.recoverActiveProfile());

@Test
public void testProfileQA()

GenericXmlApplicationContext ctx = new GenericXmlApplicationContext();
ctx.getEnvironment().setActiveProfiles(QA_PROFILE);
ctx.load(“classpath:spring31-test-beans.xml”);
ctx.refresh();

// Profile de QA
ProfileEspecificBean profileBean = ctx.getBean(“profileBean”,
ProfileEspecificBean.class);

Assert.assertEquals(QA_PROFILE, profileBean.recoverActiveProfile());

}

Algumas coisas diferentes estão acontecendo nesse teste.
Estou instanciando um GenericXmlApplicationContext para carregar meus arquivos de beans, isso porque esse application context me disponibiliza um método que é importante para nosso teste: getEnvironment(). Com isso conseguimos acessar o environment do application context, e mais do que isso, conseguimos setar os profiles que estão ativos usando setActiveProfiles. Repare que é possível de setar mais de um profile como ativo, e que os beans podem precisar de mais de um profile para serem instanciados.
Outro fato importante, é que este environment que está disponível, é uma instância de ConfigurableEnvironment. Se você tentar acessar o profile diretamtente em ApplicationContext, você estará acessando um Environment o qual não permite ativar e desativar profiles. Fica a dica.

Após ativar o profile que queremos, basta chamar o load no contexto seguido do refresh para que os beans sejam criados.
Uma vez que o bean foi criado, basta recuperá-lo e executar o teste para se certificaro que se trata do bean que estamos esperando. Note que o nome dos dois beans é o mesmo, e que apenas um deles existe no application context, pois o outro profile não está ativo.

Nested Beans

Outra maneira de definir profiles nos beans é diretamente no XML do spring. Para que isso seja possível foi necessário permitir nested beans nos arquivos de beans, ou seja, definições de beans dentro de outra definição.
Além de possibilitar a definição de diferentes profiles, essa nova funcionalidade permite que sejam definidos alguns padrões de comportamento para os beans que só se apliquem no conjunto de beans que está nested. Mas isto veremos em um próximo post.
Para testar a definição de profiles direto no XML, vamos criar um outro XML chamado spring31-test-nested-beans.xml:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

profile=“dev”>
class=“br.com.dclick.tentativas.beans.DevEspecificBean” id=“profileBean” />
>

profile=“qa”>
class=“br.com.dclick.tentativas.beans.QAEspecificBean” id=“profileBean” />
>

Feito isso, vamos criar um novo teste que é idêntico ao primeiro, com exceção do arquivo de beans especificado, afinal o comportamento deve ser o mesmo em ambos os casos:

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
26
27
28
29

@Test
public void testProfileDevXml()

GenericXmlApplicationContext ctx = new GenericXmlApplicationContext();
ctx.getEnvironment().setActiveProfiles(DEV_PROFILE);
ctx.load(“classpath:spring31-test-nested-beans.xml”);
ctx.refresh();

// Profile de DEV
ProfileEspecificBean profileBean = ctx.getBean(“profileBean”,
ProfileEspecificBean.class);

Assert.assertEquals(DEV_PROFILE, profileBean.recoverActiveProfile());

@Test
public void testProfileQAXml()

GenericXmlApplicationContext ctx = new GenericXmlApplicationContext();
ctx.getEnvironment().setActiveProfiles(QA_PROFILE);
ctx.load(“classpath:spring31-test-nested-beans.xml”);
ctx.refresh();

// Profile de QA
ProfileEspecificBean profileBean = ctx.getBean(“profileBean”,
ProfileEspecificBean.class);

Assert.assertEquals(QA_PROFILE, profileBean.recoverActiveProfile());

Sua barra do JUnit vai ficar verde e você vai ficar feliz com essa brincadeira rápida com profiles.

Ativando Profiles de outras maneiras

Ativa os profiles no código funciona muito bem no caso dos testes, mas o que realmente se aplica a vida real é poder ativar tais profiles de maneira independente da aplicação e do código propriamente dito. Por isso podemos ativar os profiles setando uma variável global chamada spring.profiles.active.
Podemos ativar tal variável de diversas maneiras, dentre elas no próprio web.xml como um parâmetro da sua Servlet do Spring:

1
2
3
4
5
6
7
8

>
-name>dispatcher-name>
-class>org.springframework.web.servlet.DispatcherServlet-class>
-param>
-name>spring.profiles.active-name>
-value>qa-value>
-param>
>

Podemos usar também JNDI, ou até mesmo uma variável de ambiente da VM Java. Se você preferir também pode ativar profiles diretamente no maven:

1	-Dspring.profiles.active=”profile1,profile2″

Fazendo Download

Se você usa o maven, basta adicionar o seguinte no seu pom:

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

>
>
>org.springframework.maven.milestone>
>Spring Maven Milestone Repository>
>http://maven.springframework.org/milestone>
>
>

>
>
>org.springframework>
>spring-core>
>3.1.0.RC1>
>
>
>org.springframework>
>spring-beans>
>3.1.0.RC1>
>
>
>org.springframework>
>spring-context>
>3.1.0.RC1>
>
>

Caso você queira baixar diretamente do site, acesse o site do spring.

Espero ter sido útil, qualquer pergunta basta enviar nos comentários.

Por @Gust4v0_H4xx0r

Out 21

Android 4.0 – Ice Cream Sandwich – SDK

Escrito por Stefan Horochovec em 1, 2.0, 4, 6, Android, Aplicativos, app, AR, bar, BI, blog, C#, class, configuração, Curso, Desenvolvimento, Download, email, err, erro, for, Google, ide, IE, if, image, imagens, int, mg, O, on, padrão, Pessoal, problema, RIA, Ria’s Geral, runtime, S+S, SDK, SmartPhone, TAT, team, Tema, UI, uint, Widget, Widgets, zend @ 10 21st, 2011 | via http://www.horochovec.com.br/blog | Sem comentários

Olá pessoal,

Me deparei com um problema com o Android SDK 4.0 lançado essa sistema e vi que muita gente está sofrendo com o mesmo problema que eu. Um crash inesperado na inicialização do AVD com a seguinte mensagem: “This application has requested the Runtime to terminate it in an unusual way. Please contact the application’s support team for more information.”

Essa semana tivemos o lançamento do Android 4.0 pela Google. Eu particularmente me identifico muito com o Android, possuo a alguns anos smartphones que rodam o sistema e sou instrutor de um curso de Android SDK em parceria com a RIACycle. Não sou um doido varrido pelo Android, mas realmente gosto de todo o seu ecossistema. Pelo fato de eu gostar tanto, desenvolver em cima da plataforma e por ser instrutor do SDK, já fui fazendo o download do novo SDK para conferir um pouco da nova versão Ice Cream Sandwich.

Alguma coisa foi alterada no ADB que algumas das minhas imagens antigas simplesmente não eram mais executadas, sempre dava o mesmo erro na hora de inicializar. Para resolver o problema, eu tive que reduzir a quantidade de memória disponibilizada para a emulação, por padrão, sempre utilizei 1GB, mas só funcionou com 512MB.

Outra situação que está fazendo crash independente da quantidade de memória, é quando eu adiciono na configuração do Hardware a propriedade “Camera Support”, sempre dá crash e não consigo iniciar o emulador.

E por fim, o último problema que eu tive foi com a opção “Launch from snapshot”. Todas as tentivas no Android 4.0 deram erro, sempre tive que iniciar com a opção “Wipe user data” selecionada.

Bom pessoal, tirei algumas telas para que vocês possam conferir a imagem para desenvolvimento. Por enquanto é isso!

Boas vindas

Aplicativos

Widgets

Discador

Navegador

Status do celular

Recebendo ligação

Atendendo Ligação

Ligação Atendida

SMS

Notification Bar

Espero ter ajudado quem está com dificuldades com o novo ADB.

Um abraço e até a próxima

Out 13

Download FlashBuilder e Flex SDK 4.6

Escrito por SamuelFacchinello em 1, 2.0, 4, 6, Adobe, AR, blog, Blogs, builder 4, C#, Download, flash, flash builder, Flash Builder 4, Flex, Flex 4, Google, html, mg, O, on, Ria’s Geral, S+S, SDK, UI, vs @ 10 13th, 2011 | via http://desenvolvendoemflex.blogspot.com/ | Sem comentários

Como falei em outro post meu (http://desenvolvendoemflex.blogspot.com/2011/09/flex-sdk-46-e-flash-builder-46.html) e para quem se inscreveu para o pré-release do flash builder e flex sdk 4.6 , já esta liberado para o download.

https://prerelease.adobe.com/

Já estou baixando o meu…

Divirta-se utilizando as novas funcionalidades

Out 2

Exemplo do novo PivotViewer do Silverlight 5 apresentado no TechEd Brasil 2011

Escrito por Kelps Sousa em .NET, 1, 2.0, 3.5, 4, 6, AR, BI, blog, C#, código, código fonte, dados, deepZoom, Download, Excel, exemplo, Exemplos, fonte, for, gc, Google, html, IE, image, lista, live, map, mg, News, novidade, Novidades, O, on, Palestra, Palestras, RIA, Ria’s Geral, S+S, SDK, silverlight, Tech, TechEd, tool, tv, Twitter @ 10 2nd, 2011 | via http://kelps-sousa.blogspot.com/ | 1 comentário

Na palestra de Silverlight 5 que apresentei este ano com Rodrigo Kono no TechEd Brasil, mostramos a nova versão do PivotViewer que vem no SDK do Silverlight 5.

Esta nova versão tem diversas melhorias, principalmente no que diz respeito ? forma de montar e utilizar a coleção de dados. Nesta nova versão não é mais necessário pré-processar a coleção usando Excel ou DeepZoom Composer e praticamente tudo pode ser feito usando Binding.

Abaixo tem um link para fazer download do código fonte do exemplo que apresentamos. Para usar este exemplo é necessário ter instalado o Tools do Silverlight 5 RC. Em breve vou publicar novos posts com mais detalhes sobre esta e outras novidades do Silverlight 5, mas por enquanto, aproveitem este exemplo.

PivotViewerSample.zip