Série Dropbox: Conectando com DropBox API Java

Olá Pessoal,

Hoje quero compartilhar uma experiência bem bacana que tive com a API do dropbox. Estou trabalhando em um projeto novo e vamos usar alguns recursos do DropBox como ferramenta  para poder automatizar alguns processos e facilitar a vida do usuário. A ideia deste post é mostrar como conectar sua aplicação com o DropBox.

Lets go…

Starting…

No inicio foi meio confuso de entender como funcionava a documentação do dropbox. É até boa, mas o tutorial não é muito objetivo. Levei algumas horas para entender nos detalhes como realmente as coisas funcionavam, até porque na primeira versão sempre que eu parava e iniciava a aplicação o code da autorização precisava ser gerado de novo. Veja os passos que precisamos fazer antes de colocar a mão no código:

  • Ir no https://www.dropbox.com/developers/apps e create app. Daí é só seguir os passos e ir respondendo as perguntas. Não tem erro aqui por serem bem diretas. No meu caso usei a opção full Access e permiti que a aplicação acesse os arquivos já existentes.  Claro que você precisa estar logado no dropbox.

dropboxapiappcreated

  • Ao clicar na app que foi criada teremos dois caras importantes, veja:

 

dropboxkeygenerated

Precisamos dessas Keys para poder conectar a nossa conta.

Pronto, só isso. Agora vamos programar.

Development

Crie um Java Project

O nosso exemplo será com Java Application somente para vermos a conexão e listagem do que temos no dropbox. O meu projeto é um maven project, portanto vamos precisar da API do dropbox. Adicione o código abaixo no pom.xml

<dependency>

<groupId>com.dropbox.core</groupId>

<artifactId>dropbox-core-sdk</artifactId>

<version>1.7.2</version>

</dependency>

 

Crie uma classe com método main do Java (chamei minha classe de Main). O código a seguir é o que está nessa página: https://www.dropbox.com/developers/core/start/java

A ideia aqui é explicar como fazer tudo funcionar. Ter apenas o código e executar não é o suficiente.  Veja o código:

public class Main {
public static void main(String[] args) {
final String APP_KEY = "KEY HERE";
final String APP_SECRET = "KEY SECRET HERE";

DbxAppInfo appInfo = new DbxAppInfo(APP_KEY, APP_SECRET);

DbxRequestConfig config = new DbxRequestConfig("JavaTutorial/1.0",
Locale.getDefault().toString());

DbxWebAuthNoRedirect webAuth = new DbxWebAuthNoRedirect(config, appInfo);
String authorizeUrl = webAuth.start();

System.out.println("AuthorizeURL " + authorizeUrl);
System.out.println("3. Copy the authorization code.");

try {
String code = new BufferedReader(new InputStreamReader(System.in)).
readLine().trim();

DbxAuthFinish authFinish = null;

authFinish = webAuth.finish(code);

DbxClient client = new DbxClient(config, authFinish.accessToken);

System.out.println("Linked account: "

+ client.getAccountInfo().displayName);
DbxEntry.WithChildren listing = client.getMetadataWithChildren("/");

System.out.println("Files in the root path:");

for (DbxEntry child : listing.children) {
System.out.println("&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; " + child.name + ": " + child.toString());
}
}
catch (DbxException e) {
e.printStackTrace();
}
catch (Exception e) {
e.printStackTrace();
}
}
}

 

Agora é que vem o pulo do gato. Se você rodar essa app e não fizer nada, o que acontece? Bem, você poderia esperar que fossem listados todos os seus arquivos que estão na raiz da sua conta do dropbox, certo? Por causa dessa linha aqui:

       DbxEntry.WithChildren listing = client.getMetadataWithChildren("/");

Rode e veja o resultado a seguir:

dropboxrunningmain

O que você precisa fazer? Copiar a URL e colar no browser. O dropbox vai solicitar allow para app que está querendo acessar, então você dar autorização e ele gera um token:

dropboxtokenbrowser

Feito isso vá para a aplicação e vamos alterar apenas uma linha veja qual:

//String code = new BufferedReader(new InputStreamReader(System.in)).readLine().trim();

String code = "TOKEN CREATED HERE";

 

Observe que comentei uma linha e coloquei o token que foi gerado na variavel code, poderia também ter digitado no console. Se tudo der certo você vai ver tudo que tem na raiz do seu dropbox:

dropboxworking

Simples, não? Você pode fazer o que quiser com os arquivos. Na documentação você pode ver como fazer o download.

Problema

Se você rodar a aplicação novamente, o code gerado acima é inválido e será preciso criar um novo. No próximo post vamos ver como resolver isso.

Abraços, see ya!!

Série AngularJS: Maven archetype com AngularJS e Yeoman

 

Olá Pessoal,

Iai vai desenvolver sua aplicação com AngularJS e Java, mas vai no archetype do maven e não tem nada? Já era, agora tem rs. Acabei de criarum archetype Maven com AngularJS + Yeoman

Lets…

Overview 


O motivo de criar esse archetype é que tenho trabalhado bastante nos últimos 4 meses com AngularJS e back-end Java e tem surgido novos projetos, alguns pequenos, outros médio porte, e ter que fazer setup toda hora é meio chato, heim? Então, para unir o útil ao agradável, resolvi um problema aqui no projeto para todos os projetos que vão trabalhar usando módulos no maven e o back-end será Java com front-end AngularJS, para evitar aquele tempo gasto em setup (mesmo que seja uma hora, já compensa). Eu já fiz outros archetypes e estão no meu github.

O que tem de legal nesse archetype?

Bem, o que tem de legal é o seguinte:

  • Hibernate 4.x já vem configurado com o Spring;
  • Spring Core 3.x;
  • MySql 5.x
  • DBUnit (configurado e pronto pra sair usando);
  • DAO Generic e Service Generic;
  • Jersey 1.x
  • AngularJS 1.0.x
  • Yeoman Tools
  • Twitter Bootstrap
  • Flyway (para db migration – opcional a configuração)

Só isso que vem de legal, rs. No AngularJs eu optei pela versão estável ao invés da Release candidate.

Como usar?

Simples. Para não repetir aqui no blog o que já escrevi no readme.md do projeto, siga os passos da instalação do archetype no seu repositório maven local.

Instalado. E agora?

Vamos criar um projeto e fazer uns ajustes como com qualquer template que vem com informações default e precisam ser ajustadas para atender ao nosso projeto.

Passo 1

Crie um novo projeto maven e escolha a opção All Catalogs e em seguida digite br. para filtrar e aparecer o archetype que acabou de instalar.

archetypeangularjscatalog

Passo 2

Escolha o archetype e preencha com as informações do seu projeto.

Passo 3

Clique em finish.

Passo 4

Seu projeto vai estar quebrado, conforme a imagem a seguir

archetypeangularjsprojectfailure

Passo 5

Abra o pom.xml do projeto webapps-web e remova a dependência webapps-core que tem configurações default do archetype

archetypewebappscoreangularjsremoved

Passo 6

Adicione a dependência do seu projeto

archetypeangularjswebappscore

Passo 7

Seu projeto deve estar assim agora:

archetypeangularjsprojectresult

Dentro de webapps-web/webapps temos a pasta apps e toda a estrutura gerada pelo Yeoman.

Passo 8

Vá na raiz do projeto e execute:

mvn tomcat:run

Aplicação deve subir agora acesse: http://localhost:8080/webapps-web/

Pronto, agora é só usar.

Claro que você vai precisar especificar as informações de banco de dados, estrutura do seu packages, etc. Vou assumir que você já conhece os frameworks(spring, hibernate, jersey etc) que o archetype aborda e sabe alterar, afinal de contas você não vai criar um projeto com Spring se não sabe mexer com o framework, concorda? Para facilitar, deixei comentários nos arquivos .xml, onde você deve alterar.

Download Archetype Maven AngularJS 

https://github.com/camilolopes/archetype-webapps-module-angularjs

Em breve stou subindo outros archetypes para projetos pequenos, aguardem mais alguns dias :D.  Se quiser ser avisado assim que publicar pode me acompanhar no github ou assinar o blog. 

Abracos. Vou ficando por aqui.

Jersey com JSON em 5min

 

Olá Pessoal,

O post de hoje tem como objetivo ensinar como retornar um objeto JSON usando Jersey em 5min. Então acredito que você já sabe o que é Jersey e o que é um objeto JSON, certo? Vou pular toda a teoria e ir direto para prática.

Lets go…

Starting

  1. Crie um projeto maven webapps
  2. No pom.xml deixe assim :

<dependency>

       <groupId>com.sun.jersey</groupId>

       <artifactId>jersey-server</artifactId>

       <version>1.8</version>

    </dependency>

    <dependency>

       <groupId>com.sun.jersey</groupId>

       <artifactId>jersey-json</artifactId>

       <version>1.8</version>

    </dependency>

<build>

    <finalName>hellojersey</finalName>

  </build>

 

Em src/main/java crie um package  e uma classe:

 

jerseypackage

HelloJerseyService.java

É a classe que terá o serviço, veja:

@Path(“/hello”)

public class HelloJerseyService {

       @GET

       @Path(“/client”)

       @Produces(MediaType.APPLICATION_JSON)

       public Client getCliente() {

             Client client = new Client();

             client.setName(“Hello World Camilo”);

             return client;

       }

}

 

@Path – aqui estamos dizendo que caminho seguir para acessar esse serviço. E para obter um cliente é através do /client sendo a url completa assim /hello/client

Crie a classe Client.java

public class Client {

       private String name; 

       public String getName() {

             return name;

       } 

       public void setName(String name) {

             this.name = name;

       }      

}

 

Abra o arquivo web.xml, pois precisamos dizer que vamos usar o Jersey e fazer umas configurações, portanto crie o servlet a seguir:

<servlet>

  <servlet-name>jersey-servlet</servlet-name>

  <servlet-class>com.sun.jersey.spi.container.servlet.ServletContainer</servlet-class>

  <init-param>

   <param-name>com.sun.jersey.config.property.packages</param-name>

   <param-value>com.camilolopes.jersey.services</param-value>

  </init-param>

  <init-param>

   <param-name>com.sun.jersey.api.json.POJOMappingFeature</param-name>

   <param-value>true</param-value>

  </init-param>

 </servlet>

 

No primeiro init-param estamos dizendo onde está o package com a classe de serviço para o Jersey.  No segundo estamos dizendo: “pode ser retornado um objeto JSON”. E aqui:

<servlet-mapping>

  <servlet-name>jersey-servlet</servlet-name>

  <url-pattern>/rest/*</url-pattern>

 </servlet-mapping>

Estamos configurando o mapping para acessar essa parte da aplicação, ou seja, será:

http://localhost:8080/hellojersey/rest/hello/client

Testando:

Execute o seguinte comando:

 maven  mvn tomcat:run

E acesse pelo browser http://localhost:8080/hellojersey/rest/hello/client

jerseyhelloworld

 

 Simples não? Vou ficando por aqui.

See ya!!

Abraços.

Usando Spring Core com múltiplos projects

Olá Pessoal,

O post hoje é bem rápido e a ideia é compartilhar com vocês um problema comum quando temos mais de um projeto com dependência e precisamos usar o applicationContext que está em outro projeto.  São coisas que a gente não decora e que normalmente faz uma vez a cada novo projeto e que certamente esquecemos com o passar do tempo. E se algum livro fala sobre o assunto, certamente nem damos atenção à esse detalhe, pois estamos ansiosos em querer meter a mão na massa.

lets go…

 

Contexto

Recentemente tive que criar um projeto com module do maven. Veja a estrutura para ficar mais claro: 

—parent

—core

—web

–dependecy of core

 

Com o desenho simples acima estou dizendo que tenho um projeto parent (pai) que tem dois filhos: core e web. E o filho web depende do projeto core. 

No projeto core temos o back-end da aplicação, ou seja, regras de negócio e persistência vão estar nesse projeto. O projeto web vai cuidar do front-end. É nele que teremos o controller, os arquivos .html, xhtml, jsp, js etc. 

Então na prática o projeto web tem um .jar do projeto core: 

<dependency>

<groupId>com.handson.core</groupId>

<artifactId>xxx-core</artifactId>

<version>1.0.0</version>

</dependency>

 

Até aqui tudo bem. Nenhum problema, certo? 

Como falei, o projeto core tem o applicationContext do Spring, já que é lá que fazemos IoC, dizemos para o spring cuidar da sessionFactory etc. 

E qual o problema?

Quando precisamos usar o ApplicationContext no web. Esse é o problema. O código a seguir não vai funcionar quando aplicação subir:

 

 @Controller

@Path(“/user”)

public class UserController {

@Autowired

@Qualifier(“userServiceImpl”)

private UserService userService;

//código omitido

}

 

Por que não vai funcionar? Porque o applicationContext está dentro de .jar de outro projeto e ao subir a aplicação precisamos dizer isso para web.xml. Uma forma simples  é criar um arquivo applicationContext em web e importar o que temos no applicationContext no projeto core. Portanto, crie um app-context.xml em resource do projeto web:

 

springprojectwebresource

E no arquivo app-context que está no projeto web, faça isso:

<beans xmlns=”http://www.springframework.org/schema/beans”

xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”

xsi:schemaLocation=”http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-2.5.xsd”> 

<import resource=”classpath*:/META-INF/app-context.xml”/>

</beans> 

Esse caminho acima é porque o arquivo no projeto core está assim:

springappcontextcore

 

Agora no arquivo web.xml no projeto xx-web deixe assim:

 springwebxml

Assim, ao subir a aplicação o arquivo que está dentro do .jar do projeto core será carregado. E no import que fizemos anteriormente dizemos para importar esse arquivo para o contexto da aplicação web que está sendo carregada. 

Pronto. Salve as alterações e execute mvn install. Suba a aplicação. Se o Spring não conseguir fazer o @Autowired ele irá reclamar logo que subir. Mas o esperado é que não tenha problemas. 

Abraços! Vou ficando por aqui. Espero que tenham gostado da dica de hoje.

Fazendo Deploy de sua aplicação JEE no OpenShift

Olá Pessoal

O post de hoje é para quem deseja fazer deploy de sua app na nuvem e sem custo. O openShift é uma plataforma de cloud da RedHat que permite fazer isso de forma gratuita, até 1 GB de Storage. Show, heim? Nunca tinha usado o OpenShift, e daí resolvi fazer o deploy da app I4JSFDemo, que é um exemplo de uso da API I4JSF.

Lets go…

Primeiro passo

Ter uma conta no OpenShift. Abra sua conta, it is very easy.

Segundo Passo

Você precisa  gerar o SSH. Se você usa o Git com o GitHub certamente vai ter um id_rsa e id_rsa.pub  em .ssh. Portanto abra o arquivo .id_rsa.pub e deixe aberto por enquanto.

Terceiro Passo

Clique em create application e siga os passos

openshiftcreateapp

Escolha em browser by tag a opção Java. Assim teremos os servers Java:

 

openshifttagjavaappserver

No meu caso vou escolher TomCat .

Quarto Passo

Após ter criado a app vá em My Application e veja que ela está lá. Clique na setinha que está apontando para a direita e assim teremos detalhes da app. Veja:

 

openshiftgitrepo

Observe que você tem o url do repositório. Faça o clone desse repositório.

Quinto Passo

git rm -r src/ pom.xml

Assim vamos remover os arquivos default criado pelo OpenShift.

Sexto Passo

Coloque seu .war em webapps

Sétimo Passo

Faça um commit  e push

 git commit –am “my first commit openshift”  git push

Aguarde o push terminar e observe que o openshift vai fazer build da sua aplicação e o deploy. 

 

openshiftpush

 

openshiftbuildsucess

Aqui eles explicam o que acontece quando faz um push:

https://www.openshift.com/developers/deploying-and-building-applications

Outro link legal:

https://github.com/openshift/origin-server/blob/master/cartridges/openshift-origin-cartridge-jbossews/README.md

Resultado:

openshiftresultapp

 

Link da APP

http://i4jsfdemo-camilolopes.rhcloud.com/i4jsfdemo/

Conclusão

  • – Deploy muito fácil;
  • – Boa documentação;
  • – Podemos logar na aplicação via command line com o Putty por exemplo;
  • – É grátis até 1GB de Storage;

Se você pretende fazer uma POC a versão free atende bem.

No mais é isso. Espero que tenham gostado do post.

See ya!!

Abraços