Arquivo

Arquivo do autor

Spring Boot – Persistindo dados

22, dezembro, 2014 Sem comentários

Hoje mostrarei um exemplo de como gerenciar informações em bancos de dados.
Antes de mais nada atualize seu Spring Boot CLI (hoje a versão 1.2).


gvm i springboot

crie um novo projeto com o auxilio do Spring Boot CLI


spring init --packageName=br.com.dados --type=gradle-project --dependencies=web,data-jpa dadosProject

O comando


spring init --list

mostra todas as opções para esse comando.

Certifique-se de que seu arquivo build.gradle se parece com esse:


buildscript {
    ext {
        springBootVersion = '1.2.0.RELEASE'
    }
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
    }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'idea'
apply plugin: 'spring-boot' 

jar {
    baseName = 'demo'
    version = '0.0.1-SNAPSHOT'
}
sourceCompatibility = 1.7
targetCompatibility = 1.7

repositories {
    mavenCentral()
}


dependencies {
    compile("org.springframework.boot:spring-boot-starter-web")
    compile("org.springframework.boot:spring-boot-starter-data-jpa")
    testCompile("org.springframework.boot:spring-boot-starter-test")
    compile("org.hsqldb:hsqldb")
}

Crie um simples entity:


package demo.domain;

import ...

@Entity
public class Banco implements Serializable {
    @Id
    @GeneratedValue
    private Long id;

    @Column(nullable = false)
    private String codigo;

    @Column(nullable = false)
    private String nome;

    public Banco() {
        super();
    }

    public Banco(String codigo, String nome) {
        this.codigo = codigo;
        this.nome = nome;
    }

    ...
    

}

crie uma interface para o repositório


package demo.domain;

import org.springframework.data.repository.CrudRepository;

public interface BancoRepository extends CrudRepository {
    Banco findByCodigo(String codigo);
}

E por fim uma classe de testes:


package demo;

import ...

@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = Application.class)
@WebAppConfiguration
public class ApplicationTests {
    @Autowired
    private BancoRepository bancoRepository;

    @Test
    public void bancoTest() {

        // create
        Banco banco = new Banco("001", "Banco do Brasil SA");
        bancoRepository.save(banco);
        Assert.assertTrue("registros encontrados = 0", bancoRepository.count() > 0);

        // read
        Banco bancoSaved = bancoRepository.findByCodigo("001");
        Assert.assertNotNull("registros nao encontrado", bancoSaved);

        // update
        bancoSaved.setNome("Banco Brasileiro SA");
        bancoRepository.save(bancoSaved);
        Banco bancoUptodate = bancoRepository.findByCodigo("001");
        Assert.assertFalse("nome nao atualizado", bancoUptodate.getNome().equalsIgnoreCase("Banco do Brasil SA"));

        // delete
        bancoRepository.delete(bancoUptodate);
        Banco bancoDeleted = bancoRepository.findByCodigo("001");
        Assert.assertTrue("entity nao apagado", bancoDeleted == null);

    }

}

Execute o teste e verá que todos passaram.

Ao analizar o código, a primeira pergunta que surge é onde os dados foram persistidos? Qual DataSource foi usado?
Observe que adicionamos ao arquivo build.gradle a dependência do banco HyperSQL DataBase (hsqldb). Isso foi suficiente para que o Spring Boot criasse automaticamente um datasource em memória e disponibilizasse para que usássemos.

Isso é legal mas não parece muito útil. Edite o arquivo application.properties adicionando as linhas abaixo que farão com que o banco de dados seja gerenciado em arquivo.


spring.jpa.hibernate.ddl-auto=update

spring.datasource.url=jdbc:hsqldb:file:banco_db

ou essas para utilizar o MySQL:


spring.jpa.hibernate.ddl-auto=update

spring.datasource.url=jdbc:mysql://localhost:3306/banco_db
spring.datasource.username=dbuser
spring.datasource.password=dbpass
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

veja aqui mais opções de configuração para esse arquivo.

Categories: Spring Boot, Springframework Tags:

Spring Boot CLI

11, dezembro, 2014 Sem comentários

Hoje mostrarei a utilização básica do Spring Boot CLI.
O Spring Boot CLI é uma ferramenta de linha de comando que auxilia na criação rápida de artefatos Spring escritos em Groovy, facilitando assim a prototipação de suas aplicações.

Instalação

Você pode instala-lo a partir dos binários ou utilizar o GVM que é uma ferramenta multiplataforma utilizada pela comunidade Groovy para gerenciar a instalação de várias ferramentas. O GVM roda em plataformas Linux, Solaris, Mac OSX, BSD, porém no Windows apenas via Cygwin. Se você usa o Windows, aconselho que baixe o Spring Boot CLI diretamente dos binários.

Instale o GVM da seguinte forma:


curl -s get.gvmtool.net | bash

em seguida a instalação do Spring Boot CLI:


gvm install springboot

digitando :


spring --version

para verificar a versão instalada.
Opcionamente você poderá configurar o Command-Line completion para obter sugestões de parâmetros e argumentos durante a utilização.
Adicione em seu arquivo de configurações de ambiente (.bash_profile por exemplo) a linha


source '~/.gvm/springboot/current/shell-completion/bash/spring'

Esse path considera que você usou o GVM, altere se necessário para apontar para pasta onde seu Spring Boot CLI foi instalado.
Na linha de commando experimente:


spring 

grab  help  jar  run  test  version

Opcionamente você poderia usar o instalador disponibilizado pela equipe do Spring:


curl http://start.spring.io/install.sh | sh

Na prática não haverá difenças no resultado, mas a primeira opção constitui um modelo padronizado para gerenciamento desta e demais ferramentas utilizadas.

Crie o arquivo Groovy SampleController.groovy


@RestController
class SampleController {

  @RequestMapping("/")
  String home() {
    "Hello World!"
  }

}

Na linha de comando digite:


spring run SampleController.groovy

Observe que essa é uma classe Groovy e portanto se beneficia da simplicidade que a linguagem oferece. O resultado, mais uma vez será o mesmo observado nos posts anteriores

Categories: geral, Spring Boot, Springframework Tags:

Spring Boot com Gradle

8, dezembro, 2014 Sem comentários

Semelhante ao Maven, instale o Gradle seguindo essas instruções, opcionalmente utilize a mesma pasta do exemplo anterior e crie o arquivo para o build do gradle: build.gradle :


buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:1.1.9.RELEASE")
    }
}

apply plugin: 'java'
apply plugin: 'spring-boot'
apply plugin: 'eclipse'
apply plugin: 'idea'

jar {
    baseName = 'gs-spring-boot'
    version =  '0.1.0'
}

repositories {
    mavenCentral()
}

dependencies {
    compile("org.springframework.boot:spring-boot-starter-web")
    testCompile("junit:junit")
}

task wrapper(type: Wrapper) {
    gradleVersion = '1.11'
}

O Gradle é mais flexível e mais simples, além de usar justamente o grande acervo de bibliotecas disponibilizadas nos repositórios Maven.

O techo


buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:1.1.9.RELEASE")
    }
}

orienta o Gradle a encontrar e disponibilizar o plugin spring-boot-gradle-plugin

As linhas:


apply plugin: 'java'
apply plugin: 'spring-boot'
apply plugin: 'eclipse'
apply plugin: 'idea'

disponibilizam tasks especializadas para projetos java, artefatos spring-boot e integração com a IDE Eclipse e Idea, respectivamente.

No terminal digite:


gradle bootRun

e mais uma vez e resultado será idêntico ao mostrado no post anterior.

No próximo post veremos a utilização de mais uma opção: o Spring Boot CLI, uma ferramenta em linha de comando que permite gerar aplicações Spring Boot ainda mais rápido.

Categories: geral, Groovy, Spring Boot Tags:

Spring Boot com Maven

6, dezembro, 2014 Sem comentários

No post anterior fiz uma breve introdução ao Spring Boot. Hoje e no próximo post irei demonstrar como executar o mesmo exemplo do post anterior utilizando duas populares ferramentas para automação de compilações: o Maven e o Gradle.

Trabalhando com o Maven

A instalação do Maven é bem simples e você pode utilizar esse guia oficial em caso de dúvidas.
Crie um novo projeto Maven utilizando sua IDE preferida ou no terminal digite:


mvn archetype:generate -DgroupId=hello -DartifactId=hello -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

O resultado será uma estrutura de pasta semelhante a essa:


hello
├── pom.xml
└── src
    ├── main
    │   └── java
    │       └── hello
    │           └── SampleController.java
    └── test
        └── java
            └── hello
                └── AppTest.java

Renomeie a classe App para SampleController e deixe-a com esse conteúdo:

package hello;

import org.springframework.boot.*;
import org.springframework.boot.autoconfigure.*;
import org.springframework.stereotype.*;
import org.springframework.web.bind.annotation.*;

@RestController
@EnableAutoConfiguration
public class SampleController {

    @RequestMapping("/")
    String home() {
        return "Hello World!";
    }

    public static void main(String[] args) throws Exception {
        SpringApplication.run(SampleController.class, args);
    }
}

No terminal digite:


mvn compile exec:java

O resultado será idêntico ao mostrado no post anterior.

No próximo post demonstrarei a utilização do Spring Boot com o Gradle.

Categories: geral, Gradle, Groovy, Spring Boot Tags:

Spring Boot

1, dezembro, 2014 Sem comentários

Spring Boot é mais uma grande idéia da equipe do Spring para facilitar nossa vida durante a criação de soluções em Java.
Baseado na arquitetura de Microservices, com ele é possível criar facilmente aplicações completas com o mínimo de esforço pois sua filosofia baseada em convenções elimina a necessidade da maior parte das configurações.

Lembro-me que a primeira solução Spring em que trabalhei tinha tantas instruções de configurações que até me perdia e ainda assim era mais simples que trabalhar com os famigerados EBJ’s. De lá prá cá isso mudou muito, hoje por exemplo é totalmente opcional a utilização de xml’s e quando falamos de Spring Boot então as configurações para levantar um aplicativo praticamente não existe. Observe esse código: 1

package hello;

import org.springframework.boot.*;
import org.springframework.boot.autoconfigure.*;
import org.springframework.stereotype.*;
import org.springframework.web.bind.annotation.*;

@RestController
@EnableAutoConfiguration
public class SampleController {

    @RequestMapping("/")
    String home() {
        return "Hello World!";
    }

    public static void main(String[] args) throws Exception {
        SpringApplication.run(SampleController.class, args);
    }
}

Considerando que as classes importadas estão em seu classpath, ao executar essa classe você terá essa saída em seu terminal:

helloWordConsole

…e em seu browser:

helloWordBrowser

Observe que apesar de ser um chato “Hello World”, você não precisou fazer nenhum configuração avançada apenas na linha 8 a anotação

@Controller

que informa ao Spring que essa classe terá atributos de um Controlador Web. Na linha 9 temos

@EnableAutoConfiguration

que orienta o Spring a abstrair as dependências de seu projeto e a melhor configuração baseado nos recursos utilizados. Na linha 12 temos a anotação padrão do Spring:

@RequestMapping("/")

que define a url que ao ser interceptada produzirá o retorno desejado.

Nas linhas 17 à 19 temos um simples método Main que informa ao Spring Boot para iniciar a aplicação usando as configurações contidas nela própria. Em resumo você tem um simples executável rodando uma aplicação web.
Apesar de não ter informado um container, o Spring Boot levantou uma versão embarcada do Tomcat automaticamente para você.

Algo que é precioso nesse modelo baseado em convenções é que apesar de toda essa abstração, é possível sobrescrever os padrões propostos por suas próprias configurações.

Num próximo post veremos como utilizar o Maven e o Gradle para gerenciar um projeto Spring Boot.

Categories: geral, Spring Boot Tags:

Gradle 1.3

24, novembro, 2012 Sem comentários

Nesses últimos dias a equipe do Gradle anunciou o release 1.3. Essa nova versão traz atualizações importantes pois o torna mais estável e otimiza a forma com algumas tarefas são realizadas.
Os usuários de Scala devem comemorar pois foi introduzido a compilação incremental o que garante um grande ganho de velocidade.
Também foi corrigido e otimizado o mecanismo de resolução de dependencias.
Vale a pena conferir.

Categories: geral, Gradle Tags:

Gradle: integração com o Eclipse

17, novembro, 2012 Sem comentários

No post anterior falamos do Gradle, uma ferramenta que dentre outras coisas é muito boa para builds.
Uma outra característica importante dela é a integração com o Eclipse além de outras importantes ferramentas de desenvolvimento.
Nesse post focaremos no Gradle Support, um plugin desenvolvido pela equipe do Springsource para complementar o STS. A instalação, como sempre, é muito simples: Caso você esteja utilizando o STS basta ir ao Dashboard e na aba “extensions” localizar e instalar o plugin “Gradle Support”.
Caso não esteja utilizando o STS, basta no menu “Install New Software” utilizar o endereço:

http://dist.springsource.com/release/TOOLS/gradle

Uma sugestão adicional é instalar o plugin para o Groovy-Eclipse pois trará recursos adicionais à edição do build.gradle.

Após instalado, crie um novo projeto utilizando a tecla Command + N (ou Ctrl +N) e escolha Gradle/Gradle Project

Outra opção é importar um projeto pré-existente: file/import/Gradle/Gradle Project

Observe que após escolher a pasta que contém o build file, é necessário ainda clicar em “Build Model” e selecionar o “Project”
Por fim, utilize o Gradle Tasks View para acessar as tasks facilmente.

Categories: Gradle Tags: ,

Gradle: bom de build

10, novembro, 2012 Sem comentários

Já ha algum tempo que uso o Maven como ferramenta de build, mas preciso confessar que sempre tive meus contra-tempos com ele. No último projeto resolvi experimentar novamente o Ant integrado ao Ivy e o resultado foi que acabei com os problemas de dependencias mas ainda permaneceu o inconveniente de trabalhar com um xml e ter que definir todos por menores.
Resolvi então experimentar o Gradle, uma ferramenta de build baseada em Groovy que traz inúmeras vantagens em relação às anteriores citadas.
É possível personalizar toda a estrutura do projeto e também se beneficiar de tasks e comportamentos padronizados.
O fato de ser em groovy permite que seus scripts sejam escritos com muita flexibilidade lançando mão dos recursos de um build associados uma poderosa linguagem.

Instalando

Baixe e descompacte a ultima versão do Gradle em um diretório e em seguida crie em seu ambiente a variável GRADLE_HOME e aponte para a essa pasta. Modifique a variável PATH adicionando $GRADLE_HOME/bin à ela.

Após isso você poderá digitar gradle -version para se certificar que tudo está ok.

Um script

Crie uma nova pasta e dentro dela seu script com o nome de build.gradle

task tarefa1 << {
	println "essa é a tarefa 1"
}

Salve-o e execute ainda nessa pasta: gradle tarefa1
O resultado será parecido com

gradle tarefa1
:tarefa1
essa é a tarefa 1

BUILD SUCCESSFUL

Total time: 2.741 secs

Ao digitar gradle tasks você verá a task “tarefa1” além de outras.
Podemos também definir a task padrão assim:

defaultTasks "tarefa1"

task tarefa1 << {
	println "essa é a tarefa 1"
}

Agora já é possível executar o script apenas com gradle

Algo prático

Você poderá utilizar o Gradle para automatizar várias tarefas, mas compilar e integrar códigos serão as mais rotineiras. Vamos criar uma pasta src/main/java e nela salve o arquivo Project1.java

public class Project1{

	public static void main(String[] args){
		System.out.println("Wello World!");
	}
} 

Altere seu script para:

apply plugin:'java'
apply plugin:'application'


mainClassName = "Project1"

Por fim execute o script gradle run para que sua classe seja executada.

Categories: geral Tags:

String – reverse

Esses dias precisei baixar um arquivo num site e ele pedia um cadastro de celular como pre-requisito para fornecer o link. Ao observar mais atentamente dá pra ver que o link é parte da própria URL, o único inconveniente é ela está ao oirártnoc contrário.
Resolver o problema não é difícil, mas é chato, foi por isso que escrevi um pequeno script groovy que recebe a url invertida, simplesmente usa a própria api do groovy para reverte-la e abri-la no browser default.


url = System.in.withReader {
print 'url: '
it.readLine()
}

println "Você digitou: $url"

java.awt.Desktop.getDesktop().browse( new URL( url.toString().reverse() ).toURI() )

Categories: Groovy Tags:

Serializador Json personalizado para Enum


Estou trabalhando num projeto com Springframework mvc onde os serviços rest são transportados em json.
Por padrão, a serialização para json é feita pelo framework Jackson que é muito bom diga-se de passagem, já que é bastante flexivel.
No meu problema de hoje precisei personalizar a serialização dos enums pois por padrão ele retorna o name do enum. É possivel por exemplo, adicionar a anotação @JsonValue para definir qual método retornará o valor desejado. No meu caso porém, eu precisava retornar o enum numa estrutura de pojo e não:


{
"name" : { "first" : "Joe", "last" : "Sixpack" },
"gender" : "MALE",
"verified" : false,
"userImage" : "Rm9vYmFyIQ=="
}

Para isso criei um serializador personalizado:


public class SimpleEnumSerializer extends JsonSerializer> {

@Override
public void serialize(Enum< ?> value, JsonGenerator jgen, SerializerProvider provider) throws IOException,
JsonProcessingException {
jgen.writeStartObject();
jgen.writeFieldName("ordinal");
jgen.writeNumber(value.ordinal());
jgen.writeFieldName("name");
jgen.writeString(value.name());
jgen.writeEndObject();
}
}

public class User {
private Gender _gender;
private Name _name;
private boolean _isVerified;
private byte[] _userImage;

@JsonSerialize(using = SimpleEnumSerializer.class)
public Gender getGender() { return _gender; }
}

com isso o resultado passa para:

{
"name" : { "first" : "Joe", "last" : "Sixpack" },
"gender" {"ordinal":0, "name":"MALE"},
"verified" : false,
"userImage" : "Rm9vYmFyIQ=="
}