Sobre Isso!

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.

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

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.

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.

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: ¹

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:

…e em seu browser:

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.