Iniciando o projeto

1. No eclipse clique em File > New > Project
2. Selecione Maven Project e clique em Next
3. Selecione Create a simple project (skipe archetype selection) e clique em Next
4. Complete os campos com os dados necessários e clique em Finish

Instalando o Spring boot

1. Vá em https://projects.spring.io/spring-boot/#quick-start
2. Copie o conteúdo de dependecies
3. Cole no pom.xml do projeto, antes do fechamento da tag </project> e salve o arquivo.

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <version>1.5.7.RELEASE</version>
    </dependency>
</dependencies>

Criando a classe de configuração

1. Crie uma classe com o nome Configuração, na pasta src/main/java

@SpringBootConfiguration
public class Configuracao {

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

Criando o controller

1. Crie uma classe com o nome indexController, na pasta src/main/java

@Controller
public class indexController {

    @RequestMapping("/")
    public String index() {
        return "index";
    }
}

Configurando o Engine Thymeleaf

1. Crie uma pasta chamada templates dentro da pasta src/main/resources
2. Crie um arquivo HTML com o nome index na pasta src/main/resources
3. Busca aqui a versão apropriada para o seu projeto https://mvnrepository.com/artifact/org.thymeleaf/thymeleaf
4. No pom.xml coloque a dependência

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
    <version>1.4.1.RELEASE</version>
</dependency>

1. Para acrescentar arquivos CSS ou Javascript
2. Crie uma pasta chamada static dentro de src/main/resource
3. Cole todo o conteúdo dos seus arquivos, com por exemplo o bootstrap

Configuração do Hibernate

1. No pom.xml acrescente essas duas dependências

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
    <version>1.4.2.RELEASE</version>
</dependency>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.40</version>
</dependency>

1. Abra a classe de configuracao

@SpringBootApplication
public class Configuracao {

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

    @Bean
    public DataSource dataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/cartorios");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        return dataSource;
    }
}

Instalação e criação do projeto

1. Primeiro baixe o Spring boot no site: https://spring.io/tools/sts/all
2. Instale o arquivo e abra-o
3. clique em file > new > Spring Starter Project
4. Em name coloque o nome do seu projeto
5. Em packing selecione o WAR
6. Em group e package coloque o nome padrão dos packages, EX:io.github.danpratese clique em next.
7. No campo de busca coloque as dependências do seu projeto, EX Web, Hibernate, e etc
8. clique em next e depois em finish.
9. Com isso basta rodar o projeto com o springboot. Clique em Run as > Sprint boot app.

Criando o primeiro Controller

1. Crie uma classe no pacote controller.

package vc.com.cartorios.controllers;

import java.util.Collection;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import vc.com.cartorios.models.Cartorio;
import vc.com.cartorios.services.CartorioService;

// diz ao spring que essa classe é um controller do tipo REST
@RestController
public class CartoriosController {

    @Autowired
    CartorioService cartorioService;

    // mapeia todas as rotas do padrao REST 

    @RequestMapping(
            method = RequestMethod.POST 
            , value = "/cartorios"
            , consumes = MediaType.APPLICATION_JSON_VALUE
            , produces = MediaType.APPLICATION_JSON_VALUE
    )
    public ResponseEntity<Cartorio> salvar(@RequestBody Cartorio cartorio) {
        Cartorio cartorioSalvo = cartorioService.salvarBD(cartorio);
        return new ResponseEntity<>(cartorioSalvo, HttpStatus.CREATED);
    }

    @RequestMapping(method = RequestMethod.GET, value = "/cartorios", produces = MediaType.APPLICATION_JSON_VALUE)
    public ResponseEntity<Collection<Cartorio>> listar() {
        Collection<Cartorio> cartoriosListados = cartorioService.listarBD();
        return new ResponseEntity<>(cartoriosListados, HttpStatus.OK);
    }

    @RequestMapping(method = RequestMethod.GET, value = "/cartorios/{id}", produces = MediaType.APPLICATION_JSON_VALUE)
    public ResponseEntity<Cartorio> buscar(@PathVariable Integer id) {
        Cartorio cartorio = cartorioService.buscarBD(id);
        if(cartorio == null) {
            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
        }
        return new ResponseEntity<>(cartorio, HttpStatus.OK);
    }

    @RequestMapping(method = RequestMethod.DELETE, value = "/cartorios/{id}")
    public ResponseEntity<Cartorio> excluir(@PathVariable Integer id) {
        Cartorio cartorio = cartorioService.buscarBD(id);

        if(cartorio == null) {
            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
        }
        cartorioService.excluirBD(cartorio);
        return new ResponseEntity<>(HttpStatus.OK);
    }

    @RequestMapping(method = RequestMethod.PUT, value = "/cartorios", consumes = MediaType.APPLICATION_JSON_VALUE)
    public ResponseEntity<Cartorio> alterar(@RequestBody Cartorio cartorio) {
        cartorioService.salvarBD(cartorio);
        return new ResponseEntity<>(HttpStatus.OK);
    }
}

Criando o Model

1. Crie uma classe no pacote models.

package vc.com.cartorios.models;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

// diz ao spring que essa clase manipula o banco de dados
@Entity
public class Cartorio {

    @Id // diz ao spring que esse atributo é o identificador da tabela
    @GeneratedValue // e que é gerado automaticamente
    private Integer id;
    private String nome;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

}

Criando o Repository do model

1. Crie uma classe no pacote repositories

implementa os métodos da JPA, automatizando as tarefas de CRUD no banco

package vc.com.cartorios.repositories;

import org.springframework.data.jpa.repository.JpaRepository;

import vc.com.cartorios.models.Cartorio;

public interface CartorioRepository extends JpaRepository<Cartorio, Integer> {

}

Criando a service(DAO) do Repository

1. Crie uma classe no pacote services

essa classe faz o DAO do projeto, usando a implementação do JPA

package vc.com.cartorios.services;

import java.util.Collection;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import vc.com.cartorios.models.Cartorio;
import vc.com.cartorios.repositories.CartorioRepository;

@Service
public class CartorioService {

    @Autowired
    CartorioRepository cartorioRepository;

    public Cartorio salvarBD(Cartorio cartorio) {
        return cartorioRepository.save(cartorio);
    }

    public Collection<Cartorio> listarBD() {
        return cartorioRepository.findAll();
    }

    public Cartorio buscarBD(Integer id) {
        return cartorioRepository.findOne(id);
    }

    public void excluirBD(Cartorio cartorio) {
        cartorioRepository.delete(cartorio);
    }
}

Configurando o Hibernate para acessar o banco

1. Abra a classe application.properties em src/main/resources

spring.datasource.url=jdbc:mysql://localhost:3306/
spring.datasource.username=root
spring.datasource.password=root
spring.jpa.hibernate.ddl-auto=create-drop

1. Abra o pom.xml na pasta raiz.
2. e cole o código a seguir antes do fechamento da tag </dependencies>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.15</version>
</dependency>

1. Via terminal acesse o banco: mysql -u root -p
2. coloque a senha do MySQL
3. crie o banco: CREATE DATABASE cartorios;
4. No eclipse rode novamente o projeto para que o Spring crie as tabelas do banco de dados.

Configurando os templetes WEB thymeleaf

1. No pom.xml cole o código a seguir, antes do fechamento da tag </dependencies>:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

1. crie uma página HTML na pasta src/main/resources/templates.
2. crie uma classe HomeController na pasta controllers.

package vc.com.cartorios.controllers;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class HomeController {

    @RequestMapping("/home")
    public String home() {
        return "index";
    }
}

1. acesse a URL: http://localhost:8080/home