Curso Spring Boot && MVC com Thymeleaf

Curso Spring Boot && MVC com Thymeleaf


Informações Complementares
--------------------------

    . Como configurar a página default quando for chamado o contexto "/" do site:

        Page index.html will be default if one this possibilities:

        Solution 1: index.html page inside public

        create an index.html page inside resources/public/index.html

        Solution 2: index.html page inside static

        create an index.html page inside resources/static/index.html

        Solution 3: Using controller Mapping

        Create a controller with@RequestMapping("/") which will return view name but for this requires any view configuration. Here is spring boot jsp example

        package com.javadeveloperzone.controller;
        import org.springframework.stereotype.Controller;
        import org.springframework.web.bind.annotation.RequestMapping;
        /**
        * Created by Java Developer Zone on 19-07-2017.
        */
        @Controller
        public class IndexController {
            @RequestMapping("/")
            public String index() {
                return "Spring Boot Example";
            }
        }

    . Principais propriedades do arquivo application.properties

        spring.main.banner-mode=off
        logging.level.org.springframework=error

        spring.jpa.hibernate.ddl-auto=none

        spring.datasource.initialization-mode=always
        spring.datasource.platform=postgres
        spring.datasource.url=jdbc:postgresql://localhost:5432/desenv
        spring.datasource.username=supervisor
        spring.datasource.password=brasil2

        spring.jpa.properties.hibernate.jdbc.lob.non_contextual_creation=true

        #Show all queries
        spring.jpa.show-sql=true
        spring.jpa.properties.hibernate.format_sql=true
        #logging.level.org.hibernate.type=error

        #spring.mvc.view.prefix=/templates/
        spring.thymeleaf.suffix=.jsp

        # Allow Thymeleaf templates to be reloaded at dev time
        spring.thymeleaf.cache: false
        spring.thymeleaf.mode: html



Aula 3 - Anotações Spring Framework

    . Principais anoteações para objetos componentes:

        @Component 
        
        É uma anotação básica para criar qualquer tipo de bean gerenciado pelo Spring Framework.
        Normalmente usada quando não se define um bean como @Repository ou @Service.

        @Repository

        Define um bean como sendo do tipo persistente para uso em classes de acesso a banco de
        dados. A partir desta anotação o Spring pode usar recursos referentes a persistência, como
        tratar as exceções específicas para este fim.

        @Service

        Usado para classes do tipo serviço (Service Layer), que possuem, por
        exemplo, regras de negócios.

        @Autowired

        Anotação usada para informar ao Spring que ele deve injetar a variável
        anotada na classe em que está declarada

        Exemplo 1

        @Service
        public class ComputadorService {
            @Autowired
            private ComputadorDao dao;

            public void salvar(Computador computador) {
                dao.saveOrUpdate(computador);
            }
        }

        @Autowired pode ser declarada sobre variáveis de instancia, métodos set()
        das variáveis de instancia e sobre métodos construtores.


        Exemplo 2

        @Service
        public class ComputadorService{
            private ComputadorDao dao;

            @Autowired
            public void setComputadorDAO(ComputadorDao dao){
                this.dao = dao;
            }

            public void salvar(Computador computador) {
                dao.saveOrUpdate(computador);
            }
        }

        Exemplo 3

        @Service
        public class ComputadorService{
            private ComputadorDao dao;

            @Autowired
            public ComputadorService(ComputadorDao dao) {
                this.dao = dao;
            }

            public void salvar(Computador computador) {
                dao.saveOrUpdate(computador);
            }
        }                

Aula 6 - Anotações do Spring MVC

    . @Controller 
    
        Transforma a classe em um bean do tipo controller do MVC.

        Exemplo:

        @Controller
        public class ComputadorController {
            //métodos e atributos omitidos
        }

    . @RequestMapping 
        
        Usada para mapear URLs de acesso a um controller e aos métodos contidos nele;

        Exemplo:

        @Controller
        @RequestMapping(“/computadores”)
        public class ComputadorController {
            
            // Também podemos definir verbos HTTP (POST, GET, ...) de acesso aos métodos.
            @RequestMapping(path = “/listagem”, method = RequestMethod.GET)
            public String getComputadores() { 

            }
        }    

        . Alguns atributos da annotation @RequestMapping:

            headers : @RequestMapping( headers=["Accept=application/json; text/html"] ["Accept="*/*"])
            produces: 


        Outras opções que podem ser usadas no lugar do @RequestMapping:

        @GetMapping
        @PostMapping
        @PutMapping
        @DeleteMapping
        @PatchMapping            

        . Exemplo de uso a partir do cliente e testando com Postman

            . Declare a função javascript na página web:

                $(document).ready(
                        function() {
                            var objPessoa =  { "nome" : "", "cpf" : "106.523.608-58"} ;

                            $("#send").on("click",function(){ 
                                $.ajax({
                                    type: "GET",
                                    url: "../pessoa/api",
                                    data:   objPessoa ,
                                    headers: {
                                    'Accept': 'application/json',
                                    'Content-Type': 'application/json'
                                    },
                                    contentType: "application/json; charset=utf-8",
                                    dataType: "json",
                                    success: function(response){ 
                                        alert(response[0].nome) 
                                    }, 
                                    failure: function (response) {
                                        alert(response.d);
                                    },
                                    error: function (response) {
                                        alert(response.d);
                                    }
                                });
                            });
                        });

            . Declare o metodo na classe restful

                @RestController
                @RequestMapping("pessoa/api")
                public class PessoaResource {

                    @Autowired
                    PessoaService pessoaService;

                    @RequestMapping(method = RequestMethod.GET, 
                                    produces = MediaType.APPLICATION_JSON_VALUE, 
                                    headers = "Accept=*/*")
                    public @ResponseBody List<Pessoa> findPessoa( Pessoa pessoa) {
                        ...
                    }
                }

            . No Postman, ir na aba .form-data e colocar o parâmetro "cpf" com value "106.523.608-58"

    . @PathVariable

        Tem o objetivo de extrair da URL um parâmetro que foi incluído como path da
        URL.

        Exemplo:

        http://localhost:8080/demo/computadores/listagem/ibm

        @Controller
        @RequestMapping(“/computadores”)
        public class ComputadorController {
            @RequestMapping(path = “/listagem/{marca}”, method = RequestMethod.GET)
            public String getComputadoresPorMarca(@PathVariable(“marca”) String marca) {
                System.out.println( marca );
            }
        }        

    . @RequestParam

        Tem o objetivo capturar um parâmetro de consulta (Query Param) enviado por
        uma solicitação.

        http://localhost:8080/demo/computadores/listagem?marca=ibm

        @Controller
        @RequestMapping(“/computadores”)
        public class ComputadorController {
            @RequestMapping(path = “/listagem”, method = RequestMethod.GET)
            public String getComputadoresPorMarca(@RequestParam(name = “marca”) String marca) {
            
            }
        }


    . @RequestBody
    
        Mapeia o corpo HttpRequest para um objeto de transferência ou domínio, permitindo a 
        desserialização automática do corpo HttpRequest de entrada em um objeto Java.


        public class LoginForm {
            private String username;
            private String password;
        //...
        }

        ...

        @PostMapping("/request")
        public ResponseEntity postController( @RequestBody LoginForm loginForm) {

            exampleService.fakeAuthenticate(loginForm);
            return ResponseEntity.ok(HttpStatus.OK);
        }

        ...

        curl -i \
        -H "Accept: application/json" \
        -H "Content-Type:application/json" \
        -X POST --data
        '{"username": "johnny", "password": "password"}' "https://localhost:8080/.../request"



    . @ResponseBody
    
        Informa a um controlador que o objeto retornado é serializado automaticamente no JSON e passado 
        de volta ao objeto HttpResponse

        public class ResponseTransfer {
            private String text;

        //standard getters/setters
        }

        ...

        @PostMapping("/response")
        @ResponseBody
        public ResponseTransfer postResponseController(
        @RequestBody LoginForm loginForm) {
            return new ResponseTransfer("Thanks For Posting!!!");
        }        


        // {"text":"Thanks For Posting!!!"}

    . @ModelAttribute

        Pode ser usado sobre a assinatura de um método ou como argumento de um método.

        Quando utilizado no metodo, ao executar a classe através de alguma das outras annotation nela
        como: @RequestMapping, ou @GetMapping, ou @PostMapping, etc. O metodo da annotation @ModelAttribute
        será executa antes de qualquer outra annotation, para somente depois ir para a annotation destino.

        Exemplo - Uso no metodo

        @Controller
        public class MyController {

            @Autowired
            private IMessageService messageService;

            @GetMapping("/pageOne")
            public String getPageOne() {

                return "pageOne";
            }

            @GetMapping("/pageTwo")
            public String getPageTwo() {

                return "pageTwo";
            }

            @ModelAttribute("motd")
            public String message() {

                return messageService.getMessage();
            }
        }

        Quando utilizado na assinatura associa os parâmetros, geralmente vindo de formulários, 
        com os atributos do componente.

        Exemplo - Uso na assinatura

        @Controller
        @RequestMapping(“/computadores”)
        public class ComputadorController {
            @PostMapping(“/save”)
            public String salvar(@ModelAttribute Computador computador) {
        
            }
       
        }

    . @Valid
        
        Anotação responsável por injetar a validação back-end via Hibernate Validator,
        Bean Validation ou Spring Validator.

        Exemplo:

        @Controller
        @RequestMapping(“/computadores”)
        public class ComputadorController {
            @PostMapping(“/save”)
            public String salvar(@Valid Computador computador) {
            
            }
        }

    
    Aula 7 - Objetos de Resposta MVC

    . ModelMap, ModelAndView, Model - Todos são objetos "forward", ou seja, são objetos levados
        para as páginas.

    . ModelMap 

        Objeto usado para enviar dados a página como resposta de uma solicitação.
        Trabalha como uma resposta do tipo forward.

        Exemplo

        @Controller
        @RequestMapping(“/computadores”)
        public class ComputadorController {

            @Autowired
            private ComputadorDao dao;

            @GetMapping(“/listagem”)
            public String getComputadores(ModelMap model) {
                List<Computador> computadores = dao.findAll();
                model.addAttribute(“computadores”, computadores);
                return “lista”;
            }
        }

    . ModelAndView

        Objeto usado para enviar dados a página como resposta de uma solicitação.

        @Controller
        @RequestMapping(“/computadores”)
        public class ComputadorController {

            @Autowired
            private ComputadorDao dao;

            @GetMapping(“/listagem”)
            public ModelAndView getComputadores() {
                List<Computador> computadores = dao.findAll();

                ModelAndView model = new ModelAndView(“lista”);

                model.addObject(“computadores”, computadores);

                return model;
            }
        }

    . Model

        @Controller
        public class GreetingController {

            @RequestMapping(path = "/getWithModel", method = RequestMethod.GET)
            public String getWithModel(@RequestParam("name") String name, Model model) {
                Greeting greeting = new Greeting(name);
                model.addAttribute("greeting", greeting);

                return "greet";
            }
        }    

        ...

        greet.html
        ----------

        <!DOCTYPE html>
        <html>
            <body>
                Hello <span th:text="${greeting.name}"/>!
            </body>
        </html>


    . Map

        @GetMapping("/getMessageAndTime")
        public String getMessageAndTime(ModelMap map) {

            var ldt = LocalDateTime.now();

            var fmt = DateTimeFormatter.ofLocalizedDateTime(
                    FormatStyle.MEDIUM);

            fmt.withLocale(new Locale("sk", "SK"));
            fmt.withZone(ZoneId.of("CET"));
            String time = fmt.format(ldt);

            map.addAttribute("message", message).addAttribute("time", time);

            return "show";
        }    

        ...

        show.fthl   Página Fremaker
        ---------
        <!DOCTYPE html>
        <html>
            <head>
                <title>Message</title>
                <meta charset="UTF-8">
                <meta name="viewport" content="width=device-width, initial-scale=1.0">
            </head>
            <body>
                <p>
                    Message: ${message}
                </p>

                <#if time??>
                    <p>Date and time: ${time}</p>
                </#if>

            </body>
        </html>

    . ModelMap & ModelAndView

        Adicionamos parâmetros de resposta no objeto ModelMap e retornamos um
        ModelAndView.

        @Controller
        @RequestMapping(“/computadores”)
        public class ComputadorController {
            @Autowired
            private ComputadorDao dao;

            @GetMapping(“/listagem”)
            public ModelAndView getComputadores(ModelMap model) {
                List<Computador> computadores = dao.findAll();
                model.addAttribute(“computadores”, computadores);
                return new ModelAndView(“lista”, model);
            }
        }

    . Redirect 
        
        É uma operação usada para redirecionar a resposta de uma solicitação a outra
        solicitação.

            @Controller
            @RequestMapping(“/computadores”)
            public class ComputadorController {
                @Autowired
                private ComputadorDao dao;

                @GetMapping(“/listagem”)
                public ModelAndView getComputadores(ModelMap model) {
                    List<Computador> computadores = dao.findAll();
                    model.addAttribute(“computadores”, computadores);
                    return new ModelAndView(“lista”, model);
                }

                @PostMapping(“/save”)
                public String addComputador(Computador computador) {
                    dao.save(computador);
                    return “redirect:/computadores/listagem”
                }
            }

        Importante: o redirect não consegue levar os objetos de parâmetos, pois esses são
                    forward.

        Redirect é uma operação usada para redirecionar a resposta de uma solicitação a outra
        solicitação.

        Importante: Para levar parâmetos através de redirect precisamos utilizar o objeto 
                    RedirectAttributes

            @Controller
            @RequestMapping(“/computadores”)
            public class ComputadorController {
                @Autowired
                private ComputadorDao dao;

                @GetMapping(“/listagem”)
                public ModelAndView getComputadores(ModelMap model) {
                    List<Computador> computadores = dao.findAll();
                    model.addAttribute(“computadores”, computadores);
                    return new ModelAndView(“lista”, model);
                }

                @PostMapping(“/save”)
                public String addComputador(Computador computador, RedirectAttributes attrib) { // <--
                    dao.save(computador);
                    attrib.addFlashAttribute(“mensagem”, “Computador inserido com sucesso”);    // <--
                    return “redirect:/computadores/listagem”
                }
            }    

        A classe RedirectAttributes também poderá ser utilizada para armazenar objetos na sessão
        para que após o redirecionamento possa ser utilizado, por exemplo:

            @PostMapping("/salvar")
            public String salvar(@ModelAttribute Departamento departamento, RedirectAttributes attr) {

                try {
                    service.salvar(departamento);
                    
                    attr.addFlashAttribute("success", "Departamento salvo com sucesso.");
                }catch( Exception e) {
                    e.printStackTrace();
                }
                
                return "redirect:/departamentos/cadastrar";
            }

            // Na página ficaria:

            <div th:if="${success} != null">
                <div class="alert alert-success alert-dismissible fade show" role="alert">
                <i class="oi oi-check"></i>
                <span>
                    <strong th:text="${success}"></strong> 
                </span>
                <button type="button" class="close" data-dismiss="alert" aria-label="Close">
                    <span aria-hidden="true">&times;</span>
                </button>
                </div>
            </div>



Aulas 9 a 13 - Iniciando o desenvolvimento do projeto

. Crie um projeto Maven com os parâmetros abaixo:

    Name : demo-mvc
    Group : com.mballem.curso.boot
    Artifact : demo-mvc
    Package : com.mballem.curso.boot

    Dependencias : Devtools, Thymeleaf, JPA, Web, Postgres

. Importar as páginas de exemplos para dentro do projeto

    . Acesse a pasta de Material do Curso Spring Boot && MVC...
    . Copie as pastas Cargo, Departamento e Funcionario; e a página home.html 
        para dentro da pasta resources/templates
    . Copie todas as subpastas da pasta "static" para dentro da pasta static do projeto.

. Acesse o arquivo application.properties e acrescente o conteúdo abaixo:

    spring.main.banner-mode=off
    logging.level.org.springframework=error

    spring.jpa.hibernate.ddl-auto=none

    spring.datasource.initialization-mode=always
    spring.datasource.platform=postgres
    spring.datasource.url=jdbc:postgresql://localhost:5432/desenv
    spring.datasource.username=supervisor
    spring.datasource.password=brasil2

    spring.jpa.properties.hibernate.jdbc.lob.non_contextual_creation=true

    #Show all queries
    spring.jpa.show-sql=true
    spring.jpa.properties.hibernate.format_sql=true
    #logging.level.org.hibernate.type=error

    #spring.mvc.view.prefix=/templates/
    #spring.thymeleaf.suffix=.jsp

    # Allow Thymeleaf templates to be reloaded at dev time
    spring.thymeleaf.cache: false
    spring.thymeleaf.mode: html

. Acesse o link abaixo para verificar o site do webjars:

    https://www.webjars.org/
    https://useiconic.com/open    

    https://www.thymeleaf.org/doc/tutorials/3.0/thymeleafspring.pdf

    . Neste link é possível localizar as bibliotecas disponíveis no 
        maven e pegar as versões mais recentes delas para linkar nos
        nossos projetos.

    . Observe que as bibliotecas vem associada ao <groupId>org.webjars</groupId>
        o que faz do webjars um grande associador de bibliotecas.

    . O site useiconic é o site onde encontra-se informações sobre os icones da biblioteca
        open-iconic

. Acesse o pom.xml e coloque as linhas abaixo nele:

    <dependency>
        <groupId>org.webjars</groupId>
        <artifactId>webjars-locator-core</artifactId>
    </dependency>

    <dependency>
        <groupId>org.webjars</groupId>
        <artifactId>bootstrap</artifactId>
        <version>4.4.1-1</version>
    </dependency>

        
    <dependency>
        <groupId>org.webjars.bower</groupId>
        <artifactId>open-iconic</artifactId>
        <version>1.1.1</version>
    </dependency>

    <dependency>
        <groupId>org.webjars</groupId>
        <artifactId>jquery</artifactId>
        <version>3.5.1</version>
    </dependency>

    <dependency>
        <groupId>org.webjars.bower</groupId>
        <artifactId>jquery-mask-plugin</artifactId>
        <version>1.14.15</version>
    </dependency>


. Como definir o path das bibliotecas dentro das paginas (<script src="..." e <link rel="...")
    de acordo com as definições do webjars.

    . É necessário que a dependência esteja definida no pom.xml, exemplo:

		<dependency>
			<groupId>org.webjars.bower</groupId>
			<artifactId>jquery-maskmoney</artifactId>
			<version>3.0.2</version>
		</dependency>

    . Para encontrar a dependência correta para inserir no pom.xml acesse o site do webjar (https://www.webjars.org/), localize a 
        biblioteca e copie a referência maven para dentro do pom.xml

    . Na estrutura do projeto, acesse o nó "Maven Dependencies";

    . Localize a biblioteca desejada;

    . Dentro da dependencia vá até o nó {lib}/META-INF/resources/webjars/

    . A partir deste nó gere o path para as tags <script...> e <link...>, por exemplo:

        Maven Dependencies
            +-- jquery-maskmoney-3.0.2.jar
                    +-- META-INF
                            +-- resources
                                    +-- web-jars
                                            +-- jquery-maskmoney    # --> o mapeamento começa aqui
                                                    +-- 3.0.2
                                                            +-- dist
                                                                 +-- jquery-maskmoney.min.js

        Exemplo:     <script th:src="@{/webjars/jquery-maskmoney/3.0.2/dist/jquery.maskMoney.min.js}"></script>

    . Para mais informações, acesse o site https://www.springboottutorial.com/spring-boot-with-jquery-and-bootstrap-web-jars
    


Aulas 14 a 19 - Classes de Dominio

. Starter para JPA

    Durante a Seção 3 vamos realizar o mapeamento objeto relacional com base em anotação da JPA. 
    Porém, para que isso seja possível, será necessário incluir no projeto as bibliotecas da JPA, 
    para se ter acesso as anotações. Por conta disso, vamos incluir o módulo de JPA do Spring 
    Framework, via starter do Spring Boot. O starter em questão será o spring-boot-starter-data-jpa, 
    como pode ser visto a seguir:

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

    Com a inclusão desta dependencia termos então acesso a todos os recursos da JPA e Hibernate para 
    os mapeamentos, operações de CRUD e até mesmo para validações com Hibernate Validator.

. Classes de Entidades

    O pacote com.mballem.curso.boot.domain vai conter as classes de entidades da aplicação. 
    Classes de entidades são aquelas que têm relação com as tabelas do banco de dados. 
    Em um banco de dados, cada linha de uma tabela é também chamada de entidade, sendo assim, 
    uma classe é conhecida como classe de entidade porque representa uma linha de uma tabela.

    As classes de entidades serão mapeadas via anotações da especificação JPA, 
    algumas dessas anotações estão descritas a seguir:

        @Entity: Usada sobre a assinatura da classe para marcá-la perante o
        Hibernate/JPA que esta é uma classe de mapeamento objeto relacional;

        @Table: Informa ao Hibernate/JPA que a tabela que está sendo mapeada
        é aquela com o nome descrito na propriedade name da anotação. A
        anotação ainda possui a propriedade indexes, onde foi configurado um
        índice que não permite que mais de uma linha na tabela contenha
        registros com o mesmo título e mesma data de início;

        @Id: Usada para mapear a coluna referente à chave primária da tabela.
        Esta anotação é obrigatória no mapeamento. Caso não seja adicionada
        uma exceção será lançada em tempo de execução;

        @GeneratedValue: É utilizada para informar que a geração da chave
        primária da entidade será gerenciada pelo Hibernate e deve ser
        adicionada junto a anotação @Id. Quando não anotamos o campo com
        essa opção, significa que a responsabilidade de gerar e gerenciar as
        chaves primárias serão da aplicação;

        @Column: Seu uso tem como finalidade mapear uma coluna da tabela. Se
        essa anotação não for declarada, o nome do atributo deverá ter o
        mesmo nome da coluna. Essa anotação possui alguns atributos para
        definir, por exemplo, se a coluna aceita valores nulos ou não
        (nullable), o tamanho de uma coluna varchar (length), entre outros;

        @Enumerated: Usada para mapear uma coluna a partir de um atributo do
        tipo enum. Assim, podemos indicar se vamos gravar esse dado de forma ordinal, 
        a partir da posição do tipo declarado no enum, ou pelo da constante.

        @OneToOne: Sua função é mapear o relacionamento entre duas tabelas no banco de 
        dados que tenha relação do tipo 1x1.

        @OneToMany: Para mapear o lado fraco da relação um para muitos. O lado fraco é o 
        lado 1, já lado forte seria o lado N da relação. Nessa anotação devemos incluir 
        o atributo mappedBy com o nome do atributo que representa o lado fraco lá no 
        mapeamento da classe de lado forte.

        @ManyToOne: Tem como objetivo mapear o atributo referente a chave estrangeira 
        em um relacionamento 1xN. A classe anotada com essa anotação é considerada o 
        lado forte da relação 1xN.

        @JoinColumn: Uma de suas funções é nomear a chave estrangeira de um relacionamento 
        1xN ou 1x1. Deve ser declarada sobre o atributo que representa a chave estrangeira.

    As classes de entidades neste projeto vão herdar da classe 
    com.mballem.curso.boot.domain.AbstractEntity algumas características 
    como os métodos getId() e setId(), além dos métodos toString(), equals() e hashCode().

    Deste modo, não será necessário implementar em cada classe de entidade a 
    propriedade id nem os métodos citados acima. Outro ponto importante é em relação a 
    interface java.io.Serializable a qual deve ser implementada em classes de entidades 
    como uma boa pratica. Essa interface será implementada em AbstractEntity, assim, 
    automaticamente as classes filhas herdarão essa característica.

. Código Fonte da classe AbstractEntity:

    package com.mballem.curso.boot.domain;

    import java.io.Serializable;
    import javax.persistence.*;

    @SuppressWarnings("serial") // Coloque esta annotation para suprimir o Warning da implementação "Serializable"
    @MappedSuperclass
    public abstract class AbstractEntity<ID extends Serializable> implements Serializable {

        @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
        private ID id;
        public ID getId() {
            return id;
        }

        public void setId(ID id) {
            this.id = id;
        }
        
        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + ((id == null) ? 0 : id.hashCode());
            return result;
        }
        
        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            
            AbstractEntity<?> other = (AbstractEntity<?>) obj;  // Corrigir a Warning colocando <?>
                                                                // que vem sem qdo fazemos a geração pelo eclipse
            if (id == null) {
                if (other.id != null)
                    return false;
            } else if (!id.equals(other.id))
                return false;
            return true;
        }
        @Override
        public String toString() {
            return "id = " + id;
        }    
    }

    As classes de entidades que irão estender AbstractEntity são Departamento, Cargo, 
    Endereco e Funcionario. No banco de dados essas classes estão, respectivamente, 
    representadas pelas tabelas: departamentos, cargos, enderecos e funcionarios. 
    E o relacionamento entre elas estão descritos a seguir:

    Departamentos (1) x (N) Cargos
    Cargos (1) x (N) Funcionarios
    Funcionarios (1) x (1) Enderecos

            +---------------------+
            |   DEPARTAMENTOS     |
            +---------------------+
            | id : bigint(20)     |
            +---------------------+
            | nome : Varchar(60)  |
            +---------------------+
                    ^
                    |
                    |   id_departamento_fk : id
                    |
                    |
    +----------------------------------+
    |              CARGOS              |
    +----------------------------------+
    | id : bigint(20)                  |
    +----------------------------------+
    | nome : Varchar(60)               |
    | id_departamento_fk : bigint(20)  |
    +----------------------------------+
                    ^
                    |
                    |   cargo_id_fk : id
                    |
                    |
    +----------------------------------+
    |         FUNCIONARIOS             |
    +----------------------------------+
    | id : bigint(20)                  |
    +----------------------------------+
    | data_entrada : date              |
    | data_saida : date                |
    | nome : varchar(255)              |
    | salario : decimal(7,2)           |
    | cargo_id_fk : bigint(20)         |
    | endereco_id_fk : bigint(20)      |
    +----------------------------------+
                    ^
                    |
                    |   endereco_id_fk : id
                    |
                    |
    +----------------------------------+
    |         ENDERECOS                |
    +----------------------------------+
    | id : bigint(20)                  |
    +----------------------------------+
    | bairro : varchar(255)            |
    | cep : varchar(9)                 |
    | cidade : varchar(255)            |
    | complemento : varchar(255)       |
    | logradouro : varchar(255)        |
    | numero : int(11)                 |
    | uf : varchar(2)                  |
    +----------------------------------+



    Para mapear o relacionamento entre as tabelas departamentos e cargos, 
    usamos as classes Departamento e Cargo. Na classe Departamento usamos a 
    anotação @OneToMany sobre a declaração do atributo cargos.

        @Entity
        @Table(name = "DEPARTAMENTOS")
        public class Departamento extends AbstractEntity<Long> {
            @Column(name = "nome", nullable = false, unique = true, length = 60)
            private String nome;
            
            @OneToMany(mappedBy = "departamento")
            private List<Cargo> cargos;
            
            // métodos get/set omitidos
        }

    Já no mapeamento da classe Cargo, a anotação @ManyToOne deve ser declarada 
    junto ao atributo departamento. Ainda sobre este atributo, declaramos a anotação 
    @JoinColumn, para informar o nome da coluna que armazena as chaves estrangeiras 
    do relacionamento na tabela de cargos.

        @Entity
        @Table(name = "CARGOS")
        public class Cargo extends AbstractEntity<Long> {
            @Column(name = "nome", nullable = false, unique = true, length = 60)
            private String nome;
            
            @ManyToOne
            @JoinColumn(name = "id_departamento_fk")
            private Departamento departamento;
            
            @OneToMany(mappedBy = "cargo")
            private List<Funcionario> funcionarios;
            // métodos get/set omitidos    
        }

    A classe Cargo também deve possuir o mapeamento do lado fraco entre os relacionamento 
    1xN com Funcionario. Sendo assim, o atributo funcionarios, do tipo java.util.List, 
    é anotado com @OneToMany.

    O valor do propriedade mappedBy deve coincidir com o nome do atributo mapeado na classe 
    Funcionario que representa a chave estrangeira deste relacionamento. 
    Este atributo é o cargo, anotado com @ManyToOne e @JoinColumn.

        @Entity
        @Table(name = "FUNCIONARIOS")
        public class Funcionario extends AbstractEntity<Long> {
            @Column(nullable = false, unique = true)
            private String nome;
            
            @Column(nullable = false, columnDefinition = "DECIMAL(7,2) DEFAULT 0.00")
            private BigDecimal salario;
            
            @Column(name= "data_entrada", nullable = false, columnDefinition = "DATE")
            private LocalDate dataEntrada;
            
            @Column(name = "data_saida", columnDefinition = "DATE")
            private LocalDate dataSaida;
            
            @OneToOne(cascade = CascadeType.ALL)
            @JoinColumn(name = "endereco_id_fk")
            private Endereco endereco;
            
            @ManyToOne
            @JoinColumn(name = "cargo_id_fk")
            private Cargo cargo; 
            
            // métodos get/set omitidos    
        }

    Veja ainda que na classe Funcionario está declarado o mapeamento 1x1 com a classe Endereco. 
    Este relacionamento será mapeado apenas em Funcionario, já que neste projeto não será 
    preciso acessar um funcionário pelo lado de endereço.

    Veja a seguir a classe Endereco, que possui um tipo enum para unidades federativas.

        @Entity
        @Table(name = "ENDERECOS")
        public class Endereco extends AbstractEntity<Long> {
            @Column(nullable = false)
            private String logradouro;
            
            @Column(nullable = false)
            private String bairro;
            
            @Column(nullable = false)
            private String cidade;
            
            @Column(nullable = false, length = 2)
            @Enumerated(EnumType.STRING)
            private UF uf;
            
            @Column(nullable = false, length = 9)
            private String cep;
            
            @Column(nullable = false, length = 5)
            private Integer numero;
            
            private String complemento;
            
            // métodos get/set omitidos     
        }

    O objeto UF é um enum declarado a partir do seguinte código fonte:

        public enum UF {
            AC("AC", "Acre"), AL("AL", "Alagoas"),
            AM("AM", "Amazonas"), BA("BA", "Bahia"),
            CE("CE", "Ceará"), DF("DF", "Distrito Federal"),
            ES("ES", "Espírito Santo"), GO("GO", "Goiás"),
            MA("MA", "Maranhão"), MT("MT", "Mato Grosso"),
            MS("MS", "Mato Grosso do Sul"), MG("MG", "Minas Gerais"),
            PA("PA", "Pará"), PB("PB", "Paraíba"),
            PR("PR", "Paraná"), PE("PE", "Pernambuco"),
            PI("PI", "Piauí"), RJ("RJ", "Rio de Janeiro"),
            RN("RN", "Rio Grande do Norte"), RS("RS", "Rio Grande do Sul"),
            RO("RO", "Rondônia"), RR("RR", "Roraima"),
            SC("SC", "Santa Catarina"), SP("SP", "São Paulo"),
            SE("SE", "Sergipe"), TO("TO", "Tocantins");
            
            private String sigla;
            private String descricao;
            
            UF(String sigla, String descricao) {
                this.sigla = sigla;
                this.descricao = descricao;
            }
            public String getSigla() {
                return sigla;
            }
            public String getDescricao() {
                return descricao;
            }
        }

    . Possível Erro

    Durante esta seção incluímos no projeto o spring-boot-starter-data-jpa, o qual pode 
    vir a prejudicar a inicialização do projeto. Sendo assim, caso tenha tentado 
    inicializar a aplicação após a inclusão deste starter, possivelmente 
    você teve um erro exibido no console.

    Esse erro acontece porque o starter busca por um configuração de conexão com um 
    banco de dados e também por um driver de conexão, itens que ainda não foram 
    incluídos no projeto. Então, não se preocupe, na Seção 4, vamos trabalhar na camada 
    de persistência e nesse momento vamos configurar o banco de dados.

    . Código Fonte

    Caso tenha tido algum tipo de dificuldade para acompanhar a desenvolvimento do código 
    fonte até o final desta seção, ele está disponível para download na área Materiais para download.



Aulas 20 a 23 - Camada de persistência

. Configurando o Acesso ao Banco de Dados

    O projeto desenvolvido neste curso terá Hibernate/JPA para realizar as operações de 
    CRUD (create, retrieve, update, delete). Por conta disso, é necessário configurar 
    o acesso ao banco de dados, informando, por exemplo, a URL de conexão.

    No Spring Boot essas informações devem ser passadas como propriedades no arquivo 
    application.properties, localizado no diretório src/main/resources do projeto. 
    Porém, estas propriedades são convencionadas pelo Spring Boot, ou seja, o nome 
    das propriedades já estão pré-definidos. Para encontrar a lista de propriedades, 
    do Spring Boot, devemos acessar o guia de referência, mais especificamente 
    no Apêndice A.

    As propriedades que serão utilizadas neste projeto são as seguintes:

    #DATASOURCE
    spring.datasource.platform=postgres
    spring.datasource.url=jdbc:postgresql://localhost:5432/desenv
    spring.datasource.username=supervisor
    spring.datasource.password=brasil2
    
    #JPA
    spring.jpa.hibernate.ddl-auto = update
    spring.jpa.show-sql = true
    spring.jpa.open-in-view = true
    spring.jpa.hibernate.use-new-id-generator-mappings = false

    No grupo de propriedades spring.datasource é onde informamos os dados para a conexão 
    com o banco de dados, como url, usuário e senha.

    Observe que na url declarada tem o símbolo de interrogação. Ele indica que um parâmetro 
    será adicionada a esta url. No caso o parâmetro createDatabaseIfNotExist, 
    setado como true, vai fazer com que no primeiro acesso ao MySQL, 
    caso o banco de dados demo_mvc não exista, seja então criado.

    Você deve ter percebido que a propriedade com o nome da classe do driver de conexão 
    não aparece entre estas propriedades. Isso porque, o Spring Boot consegue 
    reconhece-la a partir do driver de conexão adicionado como dependência no arquivo pom.xml.

    Por fim, as propriedades do grupo spring.jpa são para definir alguns recursos no uso da 
    JPA com o Hibernate. Entre elas informamos que as tabelas e colunas devem ser criadas 
    no banco de dados a partir dos mapeamentos adicionados nas classes de entidades.

    A propriedade xxx.show-sql setada como true vai imprimir no log as operações de CRUD, 
    ou seja, as instruções SQL geradas pelo Hibernate que são enviadas para o banco de dados.

    A xxx.open-in-view habilita o filtro do Spring responsável por manter aberta uma transação 
    até que o request esteja encerrado. Isso vai garantir que não haja exceções do tipo 
    Lazy Exception em operações com Fetch.LAZY. Esse tipo de situação pode ocorrer quando 
    mapeamos um atributo com uma anotação do tipo @OneToMany ou @ManyToMany.

    Por fim, a propriedade xxx.hibernate.use-new-id-generator-mappings, quando recebe o valor true, 
    faz com que o Hibernate gere as chaves primárias nas tabelas conforme o tipo padrão do SGDB. 
    Se você não deseja esse comportamento, deve setar essa propriedade como false, assim, 
    o Hibernate vai gerar as chaves primárias conforme o que foi definido em cada classe 
    de entidade pela anotação @GeneratedValue.


. Camada de Persistência

    A camada de persistência do projeto apresentado neste curso será baseada no padrão de projetos 
    Data Access Object (DAO). Existem algumas diferentes formas de implementar este padrão e a 
    adotada no curso vai trabalhar com um classe genérica, que irá fornecer aos DAO’s específicos 
    alguns métodos comuns como: save, update, delete, findById e findAll.

    Desta forma, não será necessário criar estes métodos repetidamente em cada classe de DAO que 
    representará uma entidade. Outra característica da implementação do padrão DAO é criar uma 
    interface para cada classe concreta de DAO. Assim, poderemos injetar via Spring, as interfaces 
    e não as classes concretas, respeitando os princípios da injeção de dependências.

    A classe que usaremos com um tipo genérico de DAO é a AbstractDao. Parte desta classe pode 
    ser visualizada a seguir:

    public abstract class AbstractDao<T, PK extends Serializable> {
    
        @SuppressWarnings("unchecked")
        private final Class<T> entityClass = (Class<T>) 
            ( (ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
        
        @PersistenceContext
        private EntityManager entityManager;
    
        protected EntityManager getEntityManager() {
            return entityManager;
        }
        
        public void save(T entity) {     
            // código omitido
        }
        
        public void update(T entity) {            
            // código omitido
        }
        
        public void delete(PK id) {            
            // código omitido
        }
        
        public T findById(PK id) {            
            // código omitido
        }
        
        public List<T> findAll() {
            // código omitido
        }    
        
        protected List<T> createQuery(String jpql, Object... params) {            
            // código omitido
        }
    }

    Na assinatura da classe temos dois tipos genéricos de dados, o T que representa o 
    tipo de entidade que está sendo enviado para a operação de CRUD e o PK representa o 
    tipo de dado referente ao identificador.

    Já o atributo entityClass vai ser responsável por fornecer a classe referente ao tipo 
    de entidade que está sendo persistida. Por exemplo, ao persistir um objeto cargo, o tipo 
    de classe de objeto é Cargo.class. Essa informação é importante principalmente para as 
    operações de leitura. Essa informação é então recuperada a partir da API Reflection do Java.

    Outro ponto importante é o acesso ao objeto EntityManager da JPA, o qual é injetado na 
    classe via anotação @PersistenceContext da própria especificação JPA.

    E o método getEntityManager() vai retornar uma instancia de EntityManager para qualquer 
    classe de DAO especifico que fizer a chamada a ele. Assim, se for necessário criar um novo 
    método de CRUD, que não seja fornecido pela classe AbstractDao, ele poderá ser criado 
    especificamente na classe concreta CargoDao, DepartamentoDao ou FuncionarioDao.

    Agora veja um exemplo do restante da implementação do padrão DAO nesta camada de persistência, 
    o qual é apresentado para persistir entidades do tipo Departamento.

    Primeiro temos um interface que define os métodos que serão implementados para Departamento.

    public interface DepartamentoDao {
    
        void save(Departamento departamento);
    
        void update(Departamento departamento);
    
        void delete(Long id);
    
        Departamento findById(Long id);
    
        List<Departamento> findAll();
    }

    A interface deverá então, ser implementada na classe DepartamentoDaoImpl. Esta classe também 
    vai estender AbstractDao e assim, herdará a implementação de seus métodos.

    @Repository
    public class DepartamentoDaoImpl 
        extends AbstractDao<Departamento, Long> implements DepartamentoDao {
        // demais métodos
    }

    Qualquer método adicional, seja de escrita ou leitura, deverá ter a assinatura declarada 
    na interface DepartamentoDao e ser implementado em DepartamentoDaoImpl.

    Por fim, transformamos a classe DepartamentoDaoImpl em um bean do Spring com o uso da 
    anotação @Repository.


Aulas 24 a 27 - Camada de persistência

. Gerenciando Transações

    O Spring Framework fornece um sistema de gerenciamento de transações baseado no uso da 
    anotação @Transactional. Essa anotação pode ser utilizada tanto sobre a assinatura da 
    classe quanto sobre a assinatura dos métodos da classe. Além disso, se pode também 
    anotar a classe e sobrescrever o comportamento transacional dos métodos anotando 
    individualmente cada um dos métodos dessa classe.

    Veja a seguir um exemplo de como fazer uso do sistema de gerenciamento transacional do 
    Spring Framework:

    @Transactional(readOnly = false)    
    public  class  FooServiceImpl  implements  FooService {
        
        @Autowired    
        private  DefaultFooDao  dao;
    
        @Transactional(readOnly = true)    
        Foo  getFoo(String  fooName) {
    
        };
    
        @Transactional(readOnly = true)    
        Foo  getFoo(String  fooName, String  barName) {
    
        };
    
        void  insertFoo(Foo  foo) {
    
        };
    
        void  updateFoo(Foo  foo) {
    
        };    
    }

    No código apresentado a @Transactional da assinatura da classe tem um atributo setado como false. 
    Esse atributo, o readOnly, vai informar ao Spring que a transação não é apenas de leitura, ou seja, 
    ela deve ser usada tanto em métodos de consulta como de escrita.

    Já nos métodos getFoo() a anotação da classe foi sobrescrita e readOnly foi setado como true. 
    Nesse caso, os métodos getFoo() serão específicos para leitura. Esse comportamento vai fazer 
    com que não seja aberta uma transação quando o método de consulta for executado, 
    liberando assim, o acesso a tabela em questão para outras operações. 
    Essa prática melhora a performance do banco de dados.

    É importante ressaltar que o valor padrão de readOnly é false, sendo assim, não é necessário 
    declarar o readOnly como false a não seja que seja para sobrescrever um readOnly setado 
    como true na assinatura da classe.

    A @Transactional fornece outras configurações baseadas em atributos como de isolamento, 
    comportamento de roll-back, tempo para time-out, entre outras, as quais podem ser 
    consultadas na documentação do Spring Framework. Essas propriedades adicionais já são pré 
    configuradas por valores padrões. Tenha certeza que sabe o que está fazendo se resolver 
    alterar estes valores, já que isso vai impactar diretamente no processo transacional de 
    seus métodos.

. Diferença entre transações no DAO e Service


    Embora pareça trivial adicionar o processo de transações nas classes da camada de persistência, 
    é muito comum colocar esse gerenciamento em uma camada acima, como exemplo, a camada de serviço.

    Um exemplo do porquê não trabalhar com a @Transactional na camada de persistência é que as 
    fazes uma mesma operação vai precisar ser controlada pela mesma transação. Suponha assim, 
    que você tenha duas classes do tipo DAO e em uma classe do tipo Service um mesmo método 
    faz uso da operação de insert dos dois DAO’s. Veja um exemplo a seguir:

    @Transactional    
    public  class  ArtigoDaoImpl  implements  ArtigoDao  {        
        void  insert(Artigo artigo) {
            // código omitido
        };    
    }
    
    @Transactional    
    public  class  RevistaDaoImpl  implements  RevistaDao  {    
        void  insert(Revista  revista) {
            // código omitido        
        };    
    }
    
    public  class  RevistaServiceImpl  implements  RevistaService  {    
        @Autowired        
        private  ArtigoDao  artigoDao;        
        @Autowired        
        private  RevistaDao  revistaDao;
        
        void  insert(Artigo artigo, Revista revista) {        
            artigoDao.insert(artigo);
            
            revista.setArtigo(artigo);
            
            revistaDao.insert(revista);
        
        };    
    }

    Analisando este cenário, quando o método insert() do Service faz a chamada ao insert() 
    de ArtigoDao, uma transação lá no DAO será aberta, comitada e fechada. O fluxo do 
    processo volta então para o método insert() do Service. Nesse momento o artigo inserido 
    na base de dados será setado como valor no objeto revista via método setArtigo(). 
    Em seguida, revistaDao vai persistir o objeto revista onde uma nova transação será 
    aberta, comitada e fechada em RevistaDao.

    Até aqui tudo bem, mas se vier a ocorrer um erro qualquer na operação de insert() 
    de RevistaDao, um roll back seria executado. Esse roll back atingiria apenas 
    RevistaDAO e não ArtigoDAO. Esse comportamento se deve por ArtigoDao já ter sido 
    comitado e não estar dividindo a mesma transação com RevistaDao. Nesse caso as duas 
    transações estão isoladas, ou seja, uma não sabe que a outra existe. Por isso, o 
    roll back não vai atingir a transação de ArtigoDao e teríamos assim, um artigo salvo na 
    base de dados sem qualquer vinculo com uma revista.

    Para resolver situações como essa, usamos o gerenciamento de transações em uma 
    camada superior, normalmente a de serviço. Dessa forma, o método da camada de 
    serviço será o responsável por gerenciar as transações e, caso o mesmo erro venha 
    a ocorrer, o roll back vai alcançar as duas operações de insert() realizadas
    nos DAO’s, já que elas estão dividindo o mesmo gerenciamento transacional da camada 
    de serviço. Veja como o código seria nesse novo cenário:

    public  class  ArtigoDaoImpl  implements  ArtigoDao  {        
        void  insert(Artigo artigo) {
            // código omitido
        };    
    }
    
    public  class  RevistaDaoImpl  implements  RevistaDao  {    
        void  insert(Revista  revista) {
            // código omitido
        };    
    }
    
    @Transactional   
    public  class  RevistaServiceImpl  implements  RevistaService  {    
        @Autowired        
        private  ArtigoDao  artigoDao;        
        @Autowired        
        private  RevistaDao  revistaDao;
        
        void  insert(Artigo artigo, Revista revista) {        
            artigoDao.insert(artigo);
            
            revista.setArtigo(artigo);
            
            revistaDao.insert(revista);
        
        };    
    }

. Camada de Serviço

    No projeto abordado neste curso a camada de serviço vai conter as interfaces 
    DepartamentoService, CargoService e FuncionarioService. Essas interfaces serão 
    implementadas em classes concretas que são, respectivamente: DepartamentoServiceImpl, 
    CargoServiceImpl e FuncionarioServiceImpl.

    Veja a seguir um exemplo, da camada de serviço, apresentado a partir da 
    interface CargoService e sua implementação:

    public interface CargoService {        
        void salvar(Cargo cargo);        
        void editar(Cargo cargo);        
        void excluir(Long id);        
        Cargo buscarPorId(Long id);            
        List<Cargo> buscarTodos();  
    }
    
    @Service @Transactional(readOnly = false)
    public class CargoServiceImpl implements CargoService {    
        @Autowired
        private CargoDao dao;
    
        @Override
        public void salvar(Cargo cargo) {
            dao.save(cargo);        
        }
        
        @Override
        public void editar(Cargo cargo) {
            dao.update(cargo);        
        }
        
        @Override
        public void excluir(Long id) {
            dao.delete(id);        
        }
    
        @Override @Transactional(readOnly = true)
        public Cargo buscarPorId(Long id) {            
            return dao.findById(id);        
        }
        
        @Override @Transactional(readOnly = true)
        public List<Cargo> buscarTodos() {        
            return dao.findAll();
        }    
    }

    Observe que a classe CargoServiceImpl tem em sua assinatura duas anotações. 
    A @Service é responsável por transformar a classe em um bean gerenciado pelo Spring.
    Já a @Transactional está trazendo para os métodos dessa classe o gerenciamento das 
    transações. Esta anotação está com o valor padrão false atribuído ao atributo 
    readOnly. Dessa forma todos os métodos da classe vão exigir uma transação, 
    sendo eles de leitura ou de escrita.

    Porém, os método buscarPorId() e buscarTodos() sobrescrevem o readOnly para true, 
    fazendo com que as operações executadas por eles não usem transações para as 
    operações de leitura.

    Use essa mesma estrutura para desenvolver as interfaces e suas classes de 
    implementação para Departamento e Funcionario.

. Testes automáticos

    . Construa as classes abaixo no pacote de testes /src/test/java

    Classe No. 1 - DepartamentoServiceTests
    ---------------------------------------

        package com.mballem.curso.boot;

        import static org.junit.Assert.assertEquals;
        import static org.junit.jupiter.api.Assertions.assertNotEquals;
        import static org.junit.jupiter.api.Assertions.assertNull;

        import java.util.List;

        import org.junit.jupiter.api.MethodOrderer.OrderAnnotation;
        import org.junit.jupiter.api.Order;
        import org.junit.jupiter.api.Test;
        import org.junit.jupiter.api.TestMethodOrder;
        import org.junit.runner.RunWith;
        import org.slf4j.Logger;
        import org.slf4j.LoggerFactory;
        import org.springframework.beans.factory.annotation.Autowired;
        import org.springframework.boot.test.context.SpringBootTest;
        import org.springframework.test.annotation.Rollback;
        import org.springframework.test.context.junit4.SpringRunner;
        import org.springframework.transaction.annotation.Transactional;

        import com.mballem.curso.boot.domain.Departamento;
        import com.mballem.curso.boot.service.DepartamentoServiceImpl;


        @TestMethodOrder(OrderAnnotation.class)		// Annotation para informar que a ordem da execução dos testes será pela annotation @Order
        @RunWith(SpringRunner.class)
        @SpringBootTest(classes=DemoMvcApplication.class)
        @Transactional
        class DepartamentoServiceTests {
            private Logger logger = LoggerFactory.getLogger(this.getClass());

            @Autowired
            DepartamentoServiceImpl service;
            
            @Test
            void contextLoads() {
            }
            
            @Test
            @Order(1)		// Direciona a ordem da execução dos testes
            void testFindById() throws Exception {
                logger.info("\n Testing is Running findById()");
                
                try {
                    Departamento departamento = service.buscarPorId(1L);
                    
                    logger.info("\n DepartamentoServiceImpl.buscarPorId(1) {}", departamento );
                    
                    assertEquals("Contabilidade", departamento.getNome());
                } catch (Exception e) {
                    e.printStackTrace();
                    
                    throw new Exception( e.getMessage() ); // TODO: handle exception
                }
            }
            @Test
            @Order(2)		// Direciona a ordem da execução dos testes
            void testFindAll() throws Exception {
                logger.info("\n Testing is Running findAll()");
                
                try {
                    List<Departamento> departamentos = service.buscarTodos();
                    
                    assertNotEquals(0, departamentos.size());
                    
                    logger.info("\n DepartamentoService.findAll() {}", departamentos );
                } catch (Exception e) {
                    e.printStackTrace();
                    
                    throw new Exception( e.getMessage() ); // TODO: handle exception
                }
            }
            
            @Test
            @Rollback(true)
            @Order(3)
            public void testUpdateDepartamento() throws Exception {
                logger.info("\n Testing is Running update()");
                
                try {
                    Departamento departamento = service.buscarPorId(1L);
                    
                    departamento.setNome("Contabilidade Updated");
                    
                    service.editar(departamento);
                    
                    departamento = service.buscarPorId(1L);
                    
                    assertEquals("Contabilidade Updated", departamento.getNome());		

                    logger.info("\n DepartamentoService.editar() {}", departamento );
                }catch( Exception e) {
                    e.printStackTrace();
                    
                    throw new Exception( e.getMessage() ); // TODO: handle exception
                }
            }
            
            @Test
            @Rollback(true)
            @Order(4)
            public void testInsertDepartamento() throws Exception {
                logger.info("\n Testing is Running insert()");

                try {
                    Departamento departamento = new Departamento("DEPARTAMENTO Inserted", null);
                    
                    service.salvar(departamento);
                    
                    assertNotEquals(0, departamento.getId());		

                    logger.info("\n DepartamentoService.salvar() {}", departamento );
                }catch( Exception e) {
                    e.printStackTrace();
                    
                    throw new Exception( e.getMessage() ); // TODO: handle exception
                }
            }

            @Test
            @Rollback(true)
            @Order(5)
            public void testDeleteDepartamento() throws Exception {
                logger.info("\n Testing is Running delete()");
                
                try {
                    Departamento departamento = new Departamento("DEPARTAMENTO Inserted", null);
                    
                    service.salvar(departamento);
                    
                    
                    service.excluir(departamento.getId());
                    
                    
                    Departamento departamento2 = service.buscarPorId(departamento.getId());
                    
                    assertNull( departamento2 );		
                    
                    logger.info("\n DepartamentoService.excluir() {}", service.buscarTodos() );
                }catch( Exception e) {
                    e.printStackTrace();
                    
                    throw new Exception( e.getMessage() ); // TODO: handle exception
                }
            }
        }



    Classe No. 2 - CargoServiceTests
    --------------------------------

        package com.mballem.curso.boot;

        import static org.junit.Assert.assertEquals;
        import static org.junit.jupiter.api.Assertions.assertNotEquals;
        import static org.junit.jupiter.api.Assertions.assertNull;

        import java.util.List;

        import org.junit.jupiter.api.MethodOrderer.OrderAnnotation;
        import org.junit.jupiter.api.Order;
        import org.junit.jupiter.api.Test;
        import org.junit.jupiter.api.TestMethodOrder;
        import org.junit.runner.RunWith;
        import org.slf4j.Logger;
        import org.slf4j.LoggerFactory;
        import org.springframework.beans.factory.annotation.Autowired;
        import org.springframework.boot.test.context.SpringBootTest;
        import org.springframework.test.annotation.Rollback;
        import org.springframework.test.context.junit4.SpringRunner;
        import org.springframework.transaction.annotation.Transactional;

        import com.mballem.curso.boot.domain.Cargo;
        import com.mballem.curso.boot.domain.Departamento;
        import com.mballem.curso.boot.service.CargoServiceImpl;


        @TestMethodOrder(OrderAnnotation.class)		// Annotation para informar que a ordem da execução dos testes será pela annotation @Order
        @RunWith(SpringRunner.class)
        @SpringBootTest(classes=DemoMvcApplication.class)
        @Transactional
        class CargoServiceTests {
            private Logger logger = LoggerFactory.getLogger(this.getClass());

            @Autowired
            CargoServiceImpl service;
            
            @Test
            void contextLoads() {
            }
            
            @Test
            @Order(1)		// Direciona a ordem da execução dos testes
            void testFindById() throws Exception {
                logger.info("\n Testing is Running findById()");
                
                try {
                    Cargo cargo = service.buscarPorId(1L);
                    
                    logger.info("\n CargoServiceImpl.buscarPorId(1) {}", cargo );
                    
                    assertEquals("Auxiliar Contábil", cargo.getNome());
                } catch (Exception e) {
                    e.printStackTrace();
                    
                    throw new Exception( e.getMessage() ); // TODO: handle exception
                }
            }
            @Test
            @Order(2)		// Direciona a ordem da execução dos testes
            void testFindAll() throws Exception {
                logger.info("\n Testing is Running findAll()");
                
                try {
                    List<Cargo> cargos = service.buscarTodos();
                    
                    assertNotEquals(0, cargos.size());
                    
                    logger.info("\n CargoService.findAll() {}", cargos );
                } catch (Exception e) {
                    e.printStackTrace();
                    
                    throw new Exception( e.getMessage() ); // TODO: handle exception
                }
            }
            
            @Test
            @Rollback(true)
            @Order(3)
            public void testUpdateCargo() throws Exception {
                logger.info("\n Testing is Running update()");
                
                try {
                    Cargo cargo = service.buscarPorId(1L);
                    
                    cargo.setNome("Auxiliar Contábil Updated");
                    
                    service.editar(cargo);
                    
                    cargo = service.buscarPorId(1L);
                    
                    assertEquals("Auxiliar Contábil Updated", cargo.getNome());		

                    logger.info("\n CargoService.editar() {}", cargo );
                }catch( Exception e) {
                    e.printStackTrace();
                    
                    throw new Exception( e.getMessage() ); // TODO: handle exception
                }
            }
            
            @Test
            @Rollback(true)
            @Order(4)
            public void testInsertCargo() throws Exception {
                logger.info("\n Testing is Running insert()");

        /*
        * Acrescentar a inclusão do departamento		
        */
                
                
                try {
                    Cargo cargo = new Cargo("CARGO Inserted", null);
                    
                    service.salvar(cargo);
                    
                    assertNotEquals(0, cargo.getId());		

                    logger.info("\n CargoService.salvar() {}", cargo );
                }catch( Exception e) {
                    e.printStackTrace();
                    
                    throw new Exception( e.getMessage() ); // TODO: handle exception
                }
            }

            @Test
            @Rollback(true)
            @Order(5)
            public void testDeleteCargo() throws Exception {
                logger.info("\n Testing is Running delete()");
                
                try {
                    Cargo cargo = new Cargo("CARGO Inserted", null);
                    
                    service.salvar(cargo);
                    
                    
                    service.excluir(cargo.getId());
                    
                    
                    Cargo cargo2 = service.buscarPorId(cargo.getId());
                    
                    assertNull( cargo2 );		
                    
                    logger.info("\n CargoService.excluir() {}", service.buscarTodos() );
                }catch( Exception e) {
                    e.printStackTrace();
                    
                    throw new Exception( e.getMessage() ); // TODO: handle exception
                }
            }
        }


    Classe No. 3 - FuncionarioServiceTests
    --------------------------------------

        package com.mballem.curso.boot;

        import static org.junit.Assert.assertEquals;
        import static org.junit.jupiter.api.Assertions.assertNotEquals;
        import static org.junit.jupiter.api.Assertions.assertNull;

        import java.math.BigDecimal;
        import java.time.LocalDate;
        import java.util.List;

        import org.junit.jupiter.api.MethodOrderer.OrderAnnotation;
        import org.junit.jupiter.api.Order;
        import org.junit.jupiter.api.Test;
        import org.junit.jupiter.api.TestMethodOrder;
        import org.junit.runner.RunWith;
        import org.slf4j.Logger;
        import org.slf4j.LoggerFactory;
        import org.springframework.beans.factory.annotation.Autowired;
        import org.springframework.boot.test.context.SpringBootTest;
        import org.springframework.test.annotation.Rollback;
        import org.springframework.test.context.junit4.SpringRunner;
        import org.springframework.transaction.annotation.Transactional;

        import com.mballem.curso.boot.domain.Cargo;
        import com.mballem.curso.boot.domain.Endereco;
        import com.mballem.curso.boot.domain.Funcionario;
        import com.mballem.curso.boot.domain.UF;
        import com.mballem.curso.boot.service.CargoServiceImpl;
        import com.mballem.curso.boot.service.FuncionarioServiceImpl;


        @TestMethodOrder(OrderAnnotation.class)		// Annotation para informar que a ordem da execução dos testes será pela annotation @Order
        @RunWith(SpringRunner.class)
        @SpringBootTest(classes=DemoMvcApplication.class)
        @Transactional
        class FuncionarioServiceTests {
            private Logger logger = LoggerFactory.getLogger(this.getClass());

            @Autowired
            FuncionarioServiceImpl service;
            
            @Autowired
            CargoServiceImpl serviceCargo;
            
            @Test
            void contextLoads() {
            }
            
            @Test
            @Order(1)		// Direciona a ordem da execução dos testes
            void testFindById() throws Exception {
                logger.info("\n Testing is Running findById()");
                
                try {
                    Funcionario funcionario = service.buscarPorId(1L);
                    
                    logger.info("\n FuncionarioServiceImpl.buscarPorId(1) {}", funcionario );
                    
                    assertEquals("Jorge da Silva", funcionario.getNome());
                } catch (Exception e) {
                    e.printStackTrace();
                    
                    throw new Exception( e.getMessage() ); // TODO: handle exception
                }
            }
            @Test
            @Order(2)		// Direciona a ordem da execução dos testes
            void testFindAll() throws Exception {
                logger.info("\n Testing is Running findAll()");
                
                try {
                    List<Funcionario> funcionarios = service.buscarTodos();
                    
                    assertNotEquals(0, funcionarios.size());
                    
                    logger.info("\n FuncionarioService.findAll() {}", funcionarios );
                } catch (Exception e) {
                    e.printStackTrace();
                    
                    throw new Exception( e.getMessage() ); // TODO: handle exception
                }
            }
            
            @Test
            @Rollback(true)
            @Order(3)
            public void testUpdateFuncionario() throws Exception {
                logger.info("\n Testing is Running update()");
                
                try {
                    Funcionario funcionario = service.buscarPorId(1L);
                    
                    funcionario.setNome("Jorge da Silva Updated");
                    
                    service.editar(funcionario);
                    
                    funcionario = service.buscarPorId(1L);
                    
                    assertEquals("Jorge da Silva Updated", funcionario.getNome());		

                    logger.info("\n FuncionarioService.editar() {}", funcionario );
                }catch( Exception e) {
                    e.printStackTrace();
                    
                    throw new Exception( e.getMessage() ); // TODO: handle exception
                }
            }
            
            @Test
            @Rollback(true)
            @Order(4)
            public void testInsertFuncionario() throws Exception {
                logger.info("\n Testing is Running insert()");

        /*
        * Acrescentar a inclusão do departamento		
        */
                
                
                try {
                    Endereco endereco = new Endereco("JD CARLU","02423100","SAO PAULO","CASA C","R CARIOBA", 360, UF.SP);
                    
                    Cargo cargo = serviceCargo.buscarPorId(2L);
                    
                    Funcionario funcionario = new Funcionario();
        //new Funcionario("MARCO ANTONIO DA SILVA", new BigDecimal("11000,00"), new LocalDate(0, 0, 0), null, cargo, endereco);
                    
                    funcionario.setCargo(cargo);
                    funcionario.setDataEntrada(LocalDate.now());
                    funcionario.setDataSaida(null);
                    funcionario.setEndereco(endereco);
                    funcionario.setNome("MARCO ANTONIO DA SILVA");
                    funcionario.setSalario(new BigDecimal("11000.00"));
                    
                    service.salvar(funcionario);
                    
                    assertNotEquals(0, funcionario.getId());		

                    logger.info("\n FuncionarioService.salvar() {}", funcionario );
                }catch( Exception e) {
                    e.printStackTrace();
                    
                    throw new Exception( e.getMessage() ); // TODO: handle exception
                }
            }

            @Test
            @Rollback(true)
            @Order(5)
            public void testDeleteFuncionario() throws Exception {
                logger.info("\n Testing is Running delete()");
                
                try {
                    Endereco endereco = new Endereco("JD CARLU","02423100","SAO PAULO","CASA C","R CARIOBA", 360, UF.SP);
                    
                    Cargo cargo = serviceCargo.buscarPorId(2L);
                    
                    Funcionario funcionario = new Funcionario();
        //new Funcionario("MARCO ANTONIO DA SILVA", new BigDecimal("11000,00"), new LocalDate(0, 0, 0), null, cargo, endereco);
                    
                    funcionario.setCargo(cargo);
                    funcionario.setDataEntrada(LocalDate.now());
                    funcionario.setDataSaida(null);
                    funcionario.setEndereco(endereco);
                    funcionario.setNome("MARCO ANTONIO DA SILVA");
                    funcionario.setSalario(new BigDecimal("11000.00"));
                    
                    service.salvar(funcionario);
                    
                    service.excluir(funcionario.getId());
                    
                    Funcionario funcionario2 = service.buscarPorId(funcionario.getId());
                    
                    assertNull( funcionario2 );		
                    
                    logger.info("\n FuncionarioService.excluir() {}", service.buscarTodos() );
                }catch( Exception e) {
                    e.printStackTrace();
                    
                    throw new Exception( e.getMessage() ); // TODO: handle exception
                }
            }
        }


Aulas 29 a 35 - Thymeleaf para as Views
---------------------------------------

. Thyemeleaf Layout

    Durante esta seção o tópico principal será baseado em criar um template para nossas páginas 
    baseado em um layout padrão. Deste modo, todas aquelas partes das páginas que se repetem 
    como cabeçalho, rodapé, sidebar e até mesmo o corpo das páginas, serão transformados 
    em fragmentos.

    Estes fragmentos são divididos em páginas separadas e importados em um página principal, 
    que será a página de layout padrão. Para trabalhar com esse tipo de recurso o 
    Thymeleaf fornece alguns componentes para este fim, que são:

        th:insert - é o mais simples: ele simplesmente vai inserir o fragmento como o corpo 
                        de uma tag na página de destino.
        th:replace - substitui a tag da página de destino pelo fragmento.
        th:include - é semelhante ao th: insert, mas em vez de inserir o fragmento, ele apenas 
                        insere o conteúdo desse fragmento.
        th:fragment - define um trecho de html como um fragmento de página.

    Agora que conhecemos os componentes para lidar com fragmentos, vamos ver um breve exemplo 
    de código. Para isso, suponha que a html exibido a seguir esteja presente na página footer.html:

        <div class="footer-css">
            <span class="text-muted">©  2018 Udemy</span>
        </div>

    Para transformar esse código em um fragmento, se deve adicionar a tag principal o 
    componente th:fragment tendo como valor o nome dado ao fragmento. 

    Veja o exemplo no código a seguir:

        <div class="footer-css" th:fragment="rodape">
            <span class="text-muted">©  2018 Udemy</span>
        </div>

    Desta forma, a página footer.html tem um fragmento que pode ser incluído em outras páginas, 
    ao invés, de ficar repetindo esse trecho código em cada página da aplicação.

    Agora, suponha que temos a página index.html e nela vamos incluir o fragmento de rodapé.

        <!DOCTYPE html>    
        <html xmlns:th="http://www.thymeleaf.org">    
        <head>    
            <meta http-equiv="Content-Type" 
                content="text/html; charset=UTF-8">    
            <title>Thymeleaf</title>    
        </head>    
        <body>    
            <div>    
                <div>Qualquer outro contéudo aqui</div>   
            </div>    
            <div class="container">    
                <div>O corpo da página poderia estar aqui</div>   
            </div>    
            <footer th:replace="footer :: rodape">    
                <span>O rodapé será inserido aqui!</span>    
            </footer>    
        </body>    
        </html>

    Analisando o código apresentado veja que em <footer> foi adicionado o componente 
    th:replace. Esse componente tem como valor uma string separada por ::. 
    Ao lado esquerdo da instrução temos o nome da página que contém o fragmento e ao 
    lado direito temos o nome dado ao fragmento. Desta forma, sempre que a página index.html 
    for aberta o fragmento de rodapé vai substituir a tag <footer> pelo código do rodapé 
    que temos na página footer.html.

    Observe também, que em <html> temos a instrução que nos da acesso ao componentes do 
    Thymeleaf. Essa instrução é o namespace: xmlns:th="http://www.thymeleaf.org"

    Há também um projeto secundário que foi oficializado pelo Thyemeleaf para a inclusão 
    de fragmentos quando estes dependem de páginas que devem ser abertas por meio de 
    requisições. Ou seja, o fragmento de rodapé é um fragmento fixo, ele não se modifica 
    a cada diferente página que será aberta em sua aplicação. Já o corpo das páginas, 
    que contém os formulários ou tabelas de dados podem ser modificados conforme cada 
    página que se abre. Uma página de cadastro do funcionários pode ter o formulário 
    diferente da página de cadastro de departamentos. Para que este tipo de situação se 
    torne mais fácil de se lidar entre o controller, as requisições e os fragmento do 
    corpo das páginas, foi criado este projeto secundário.

    Inserir no application.properties as linhas abaixo:

        spring.thymeleaf.cache=false


    O projeto em questão precisa ser incluído a aplicação na forma de uma dependência 
    do Maven e a partir dai vamos ter acesso aos componentes deste projeto que devem ser 
    incluídos nas páginas para lidar com os layouts.

        <dependency>
            <groupId>nz.net.ultraq.thymeleaf</groupId>
            <artifactId>thymeleaf-layout-dialect</artifactId>
        </dependency>

    A primeira instrução que deve ser adicionada as páginas é o 
    namespace: xmlns:layout="http://www.ultraq.net.nz/thymeleaf/layout". Com sua inclusão 
    teremos acesso a dois importantes componentes:

    layout:fragment - tem como finalidade criar e nomear o fragmento de página, tem um propósito similar 
                        ao th:fragment. Porém, ele também deve ser usado para carregar o fragmento 
                        na página de destino, em substituição ao th:replace.
    layout:decorate - deve ser incluído na tag <html> da página de fragmento. Seu objetivo é 
                        informar a página de fragmento qual será a página de destino deste fragmento. 
                        Sendo assim, como valor passamos a instrução ~{nome da página de destino}.

    Veja agora um exemplo da página cadastro.html que será usado como um fragmento:

        <!DOCTYPE html>    
        <html xmlns:th="http://www.thymeleaf.org"
            xmlns:layout="http://www.ultraq.net.nz/thymeleaf/layout"
            layout:decorate="~{index}">    
        <head>    
            <meta http-equiv="Content-Type" 
                content="text/html; charset=UTF-8">    
        </head>    
        <body>    
            <div class="container" layout:fragment="corpo">    
                <form action="#" method="post">
                    <!--código omitido -->
                </form>   
            </div>    
        </body>    
        </html>

    Agora, na página index.html importamos este fragmento da seguinte forma:

        <!DOCTYPE html>    
        <html xmlns:th="http://www.thymeleaf.org"
            xmlns:layout="http://www.ultraq.net.nz/thymeleaf/layout">   
        <head>    
            <meta http-equiv="Content-Type" 
                content="text/html; charset=UTF-8">    
        </head>    
        <body>    
            <div>    
                <div>Qualquer outro contéudo aqui</div>   
            </div>    
            <div class="container" layout:fragment="corpo">    
                <div>O corpo da página poderia estar aqui</div>   
            </div>    
            <footer th:replace="footer :: rodape">    
                <span>O rodapé será inserido aqui!</span>    
            </footer>    
        </body>    
        </html>

    Observe que no <div> referente ao corpo da página temos a instrução 
    layout:fragment="corpo". Esta instrução está dizendo que um fragmento nomeado 
    como corpo deverá ser incluído neste local. Assim, qualquer página de fragmento, 
    referente ao corpo de uma página, como a cadastro.html, 
    será aberta neste local se a requisição for direcionada a ela.

    Pesquise mais sobre fragmentos na documentação oficial do Thymeleaf:

    Difference between th:insert and th:replace (and th:include)
    Thymeleaf Page Layouts
    Habilitando o plugin do Thymeleaf

    O Spring Tools Suite permite que um plugin seja utilizado para facilitar o 
    acesso aos componentes do Thymeleaf ao clicar ctrl+space nas páginas html, 
    como mostra a figura 1. O nome do plugin é "thymeleaf-extras-eclipse-plugin".


    Figura 1 - Exibindo a lista de componentes do Thymeleaf via ctrl+space.

    Caso esse plugin não esteja instalado no STS, faça a instalação através dos 
    seguintes passos:

    Na barra de tarefas vai vá até Help > Install New Software

    Em seguida clique em Add

    No formulário que será aberto digite no campo Name um nome para o plugin, como exemplo, Thymeleaf.

    Já no campo Location inclua a url do repositório referente ao plugin: 

    https://github.com/thymeleaf/thymeleaf-extras-eclipse-plugin ou 
    https://www.thymeleaf.org/eclipse-plugin-update-site/

    Confirme estas informações e prossiga com a instalação.

    Talvez seja necessário reiniciar a IDE ao final do processo. Por fim, para 
    habilitar o uso do ctrl+space como tecla de atalho aos componentes do plugin, 
    clique sobre o titulo do projeto com o botão direito do mouse e vá até a opção 
    Thymeleaf então clique no item Add Thymeleaf Nature .

    Ok, o processo está concluído!

    Se você estiver tendo problemas com a instalação baseada no link, pode tentar 
    instalar o plugin pelo pacote .zip que está disponivel para download nesta 
    página: https://bintray.com/thymeleaf/downloads/thymeleaf-extras-eclipse-plugin/

    O processo de instalação é similar, porém, ao invés de incluir a url no campo Location , 
    clique no botão Archive  que está ao lado desse campo e selecione o arquivo .zip.


    . Desenvolvimento das páginas Thymeleaf:

        . Configurações no projeto:

            Inserir no application.properties as linhas abaixo:

                spring.thymeleaf.cache=false


            O projeto em questão precisa ser incluído a aplicação na forma de uma dependência 
            do Maven e a partir dai vamos ter acesso aos componentes deste projeto que devem ser 
            incluídos nas páginas para lidar com os layouts.

                <dependency>
                    <groupId>nz.net.ultraq.thymeleaf</groupId>
                    <artifactId>thymeleaf-layout-dialect</artifactId>
                </dependency>


        . Criar a pasta "fragments" dentro de templates, crie a página HTML com conteúdo abaixo:

            fragments/footer.html
            ---------------------

            <!DOCTYPE html>
            <html>
            <head>
            <meta charset="UTF-8">
            </head>
            <body>
                <footer class="layout-footer" th:fragment="rodape">
                    <div class="container">
                        <span class="footer-copy">&copy; 2018 MBallem. Todos os	direitos reservados.</span>
                    </div>
                </footer>

            </body>
            </html>


            fragments/header.html
            ---------------------

            <!DOCTYPE html>
            <html>
            <head>
            <meta charset="UTF-8">
            </head>
            <body>
                <header th:fragment="cabecalho">
                    <nav class="navbar navbar-inverse navbar navbar-dark bg-dark fixed-top">
                        <div class="container-fluid">
                            <div class="navbar-header">
                                <button type="button" class="btn btn-dark navbar-toggle pull-left">
                                    <i class="oi oi-menu"></i>
                                </button>
                                <a class="navbar-brand " href="#">Curso Spring Boot</a>
                            </div>
                        </div>
                    </nav>
                </header>

            </body>
            </html>

            fragments/sidebar.html
            ----------------------

            <!DOCTYPE html>
            <html>
            <head>
            <meta charset="UTF-8">
            </head>
            <body>

                        <nav class="sidebar sidebar-open" th:fragment="nav-sidebar">
                            <ul class="nav nav-pills">
                                <li class="nav-item"><a class="nav-link " href="/"> <i
                                        class="oi oi-home"></i> <span>Home</span>
                                </a></li>
                            </ul>

                            <ul class="nav nav-pills">
                                <li class="nav-item"><span class="nav-link active" >Departamentos</span></li>
                                <li class="nav-item"><a class="nav-link"
                                    href="/departamentos/cadastrar"> <i class="oi oi-plus"></i> <span>Cadastrar</span>
                                </a></li>
                                <li class="nav-item"><a class="nav-link"
                                    href="/departamentos/listar"> <i class="oi oi-spreadsheet"></i>
                                        <span>Listar </span>
                                </a></li>
                            </ul>

                            <ul class="nav nav-pills">
                                <li class="nav-item"><span class="nav-link active" >Cargos</span></li>
                                <li class="nav-item"><a class="nav-link" 
                                    href="/cargos/cadastrar"> <i class="oi oi-plus"></i> <span>Cadastrar </span>
                                </a></li>
                                <li class="nav-item"><a class="nav-link" 
                                    href="/cargos/listar"> <i
                                        class="oi oi-spreadsheet"></i> <span>Listar </span>
                                </a></li>
                            </ul>

                            <ul class="nav nav-pills">
                                <li class="nav-item"><span class="nav-link active">Funcionários</span></li>
                                <li class="nav-item"><a class="nav-link" 
                                    href="/funcionarios/cadastrar"> <i class="oi oi-plus"></i> <span>Cadastrar </span>
                                </a></li>
                                <li class="nav-item"><a class="nav-link" 
                                    href="/funcionarios/listar"> <i class="oi oi-spreadsheet"></i> <span>Listar </span>
                                </a></li>
                            </ul>
                        </nav>
            </body>
            </html>

            layout.html
            ---------------------

            <!DOCTYPE html>
            <html lang="pt" xmlns="http://www.w3.org/1999¹xhtml" 
                            xmlns:th="http://www.thymeleaf.org"
                            xmlns:layout="http://www.ultraq.net.nz/thymeleaf/layout">
            <head>
                <title>Spring-Boot Básico</title>
                <meta charset="UTF-8" />
                <meta http-equiv="X-UA-Compatible" content="IE=edge" />
                <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no" />
                <meta name="description" content="" />
                <meta name="author" content="" />
                <link rel="icon" href="/image/favicon.png" />

                <!-- Bootstrap core CSS -->
                <link href="/webjars/bootstrap/css/bootstrap.min.css" rel="stylesheet" />
                <link href="/webjars/open-iconic/font/css/open-iconic-bootstrap.min.css" rel="stylesheet" />
                
                <!-- Custom styles for this template -->
                <link href="/css/style.css" rel="stylesheet" />
            </head>
            <body>
                <header th:replace="fragments/header :: cabecalho">
                    <div>Header</div>
                </header>
                
                <div  class="layout-main">
                    <aside>
                        <nav th:replace="fragments/sidebar :: nav-sidebar">
                            <span>menu</span>
                        </nav>
                    </aside>
                    
                    <section layout:fragment="corpo">
                        <div>Conteúdo do Corpo das Páginas</div>
                    </section>
                </div>
                
                <footer th:replace="fragments/footer :: rodape">
                    <div>Footer</div>
                </footer>
                
                <!-- Bootstrap core JavaScript
                ================================================== -->
                <!-- Placed at the end of the document so the pages load faster -->
                <script src="/webjars/jquery/jquery.min.js"></script>
                <script src="/webjars/jquery-mask-plugin/dist/jquery.mask.min.js"></script>
                <script	src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.12.9/umd/popper.min.js"></script>
                <script src="/webjars/bootstrap/js/bootstrap.min.js"></script>
                <script type="text/javascript">
                    
                    $(function() {
                        $('[data-toggle="popover"]').popover();
                    });
                    
                    $(document).ready(function(){
                        $(".navbar-toggle").click(function(){
                            $(".sidebar").toggleClass("sidebar-open");
                        })
                    });

                </script>
                
            </body>
            </html>

            home.html
            ---------

            <!DOCTYPE html>
            <html layout:decorate="~{layout}">
            <head>
                <meta charset="UTF-8" />
            </head>
            <body>
                
                <section class="layout-content" layout:fragment="corpo">
                
                    <nav class="navbar navbar-expand-md bg-light">
                        <div class="collapse navbar-collapse" id="navbarsExampleDefault">
                            <ul class="navbar-nav mr-auto">
                                <li class="nav-item active">
                                    <i class="oi oi-caret-right"></i>
                                    <span>Home</span>
                                </li>
                            </ul>
                        </div>
                    </nav>
                    
                    <div class="container">
                        <div id="list-home" class="row">
                            <div class="col-4">
                                <div class="list-group" id="list-tab" role="tablist">
                                    <a class="list-group-item list-group-item-action active"
                                        id="list-spring-boot-list" data-toggle="list" href="#spring-boot"
                                        role="tab" aria-controls="spring-boot">Spring-Boot</a> <a
                                        class="list-group-item list-group-item-action" id="list-sts-list"
                                        data-toggle="list" href="#sts" role="tab" aria-controls="sts">Spring
                                        Tool Suite</a> <a class="list-group-item list-group-item-action"
                                        id="list-thymeleaf-list" data-toggle="list" href="#thymeleaf"
                                        role="tab" aria-controls="thymeleaf">Thymeleaf</a> <a
                                        class="list-group-item list-group-item-action"
                                        id="list-webjars-list" data-toggle="list" href="#webjars"
                                        role="tab" aria-controls="webjars">WebJars</a> <a
                                        class="list-group-item list-group-item-action"
                                        id="list-hibernate-list" data-toggle="list" href="#hibernate"
                                        role="tab" aria-controls="hibernate">Hibernate</a> <a
                                        class="list-group-item list-group-item-action"
                                        id="list-bootstrap-list" data-toggle="list" href="#bootstrap"
                                        role="tab" aria-controls="bootstrap">Bootstrap 4</a>
                                </div>
                            </div>
                            <div class="col-8">
                                <div class="tab-content" id="nav-tabContent">
                                    <div class="tab-pane fade show active" id="spring-boot"
                                        role="tabpanel" aria-labelledby="list-spring-boot-list">
                                        <a href="https://projects.spring.io/spring-boot/">Spring Boot</a>
                                        makes it easy to create stand-alone, production-grade Spring
                                        based Applications that you can "just run". We take an
                                        opinionated view of the Spring platform and third-party libraries
                                        so you can get started with minimum fuss. Most Spring Boot
                                        applications need very little Spring configuration.
                                    </div>
                                    <div class="tab-pane fade" id="sts" role="tabpanel"
                                        aria-labelledby="list-sts-list">
                                        The <a href="https://spring.io/tools">Spring Tool Suite</a> is an
                                        Eclipse-based development environment that is customized for
                                        developing Spring applications. It provides a ready-to-use
                                        environment to implement, debug, run, and deploy your Spring
                                        applications, including integrations for Pivotal tc Server,
                                        Pivotal Cloud Foundry, Git, Maven, AspectJ, and more.
                                    </div>
                                    <div class="tab-pane fade" id="thymeleaf" role="tabpanel"
                                        aria-labelledby="list-thymeleaf-list">
                                        <a href="http://www.thymeleaf.org/">Thymeleaf</a> is a modern
                                        server-side Java template engine for both web and standalone
                                        environments. With modules for Spring Framework, a host of
                                        integrations with your favourite tools, and the ability to plug
                                        in your own functionality, Thymeleaf is ideal for modern-day
                                        HTML5 JVM web development — although there is much more it can
                                        do.
                                    </div>
                                    <div class="tab-pane fade" id="webjars" role="tabpanel"
                                        aria-labelledby="list-webjars-list">
                                        <a href="https://www.webjars.org/">WebJars</a> are client-side
                                        web libraries (e.g. jQuery ; Bootstrap) packaged into JAR (Java
                                        Archive) files.
                                    </div>
                                    <div class="tab-pane fade" id="hibernate" role="tabpanel"
                                        aria-labelledby="list-hibernate-list">
                                        <a href="http://hibernate.org/orm/">Hibernate ORM</a> enables
                                        developers to more easily write applications whose data outlives
                                        the application process. As an Object/Relational Mapping (ORM)
                                        framework, Hibernate is concerned with data persistence as it
                                        applies to relational databases (via JDBC). <br />In addition to
                                        its own "native" API, Hibernate is also an implementation of the
                                        Java Persistence API (JPA) specification. As such, it can be
                                        easily used in any environment supporting JPA including Java SE
                                        applications, Java EE application servers, Enterprise OSGi
                                        containers, etc.
                                    </div>
                                    <div class="tab-pane fade" id="bootstrap" role="tabpanel"
                                        aria-labelledby="list-bootstrap-list">
                                        <a href="https://getbootstrap.com/">Bootstrap</a> is an open
                                        source toolkit for developing with HTML, CSS, and JS. Quickly
                                        prototype your ideas or build your entire app with our Sass
                                        variables and mixins, responsive grid system, extensive prebuilt
                                        components, and powerful plugins built on jQuery.
                                    </div>
                                </div>
                            </div>
                        </div>
                    </div>
                </section>		
            </body>
            </html>

    . Atualização das páginas de cadastro.html e lista.html

        Atualização das página templates/cargo/lista.html 

            <!DOCTYPE html>
            <html layout:decorate="~{layout}">
            <head>
                <meta charset="UTF-8"/>
            </head>
            <body>

                
                    <section class="layout-content" layout:fragment="corpo">
                
                        <nav class="navbar navbar-expand-md bg-light">
                            <div class="collapse navbar-collapse" id="navbarsExampleDefault">
                                <ul class="navbar-nav mr-auto">
                                    <li class="nav-item active">
                                        <i class="oi oi-caret-right"></i>
                                        <span>Lista de Cargos</span>
                                    </li>
                                </ul>
                            </div>
                            <a class="btn btn-primary btn-md" href="/cargos/cadastrar" role="button">
                                <span class="oi oi-plus" title="Cadastro" aria-hidden="true"></span>
                                <span>Novo Cargo</span>
                            </a>
                        </nav>
                
                        <div class="container" id="listagem">
                            <div class="table-responsive">
                                <table class="table table-striped table-hover table-sm">
                                    <thead>
                                    <tr>
                                        <th>#</th>
                                        <th>Cargo</th>
                                        <th>Departamento</th>
                                        <th>Ação</th>
                                    </tr>
                                    </thead>
                                    <tbody>
                                    <tr>
                                        <td>1</td>
                                        <td>Auxiliar Contábil</td>
                                        <td>Contabilidade</td>
                                        <td colspan="2">
                                            <a class="btn btn-info btn-sm" href="/cargos/editar/1" role="button">
                                                <span class="oi oi-brush" title="Editar" aria-hidden="true"></span>
                                            </a>
                                            <button type="button" class="btn btn-danger btn-sm" >
                                                <span class="oi oi-circle-x" title="Exclusão desabilitada" aria-hidden="true"></span>
                                            </button>
                                        </td>
                                    </tr>
                                    <tr>
                                        <td>2</td>
                                        <td>Auxiliar Administrativo</td>
                                        <td>Administração</td>
                                        <td colspan="2">
                                            <a class="btn btn-info btn-sm" href="/cargos/editar/2" role="button">
                                                <span class="oi oi-brush" title="Editar" aria-hidden="true"></span>
                                            </a>
                                            <button type="button" class="btn btn-danger btn-sm" >
                                                <span class="oi oi-circle-x" title="Exclusão desabilitada" aria-hidden="true"></span>
                                            </button>
                                        </td>
                                    </tr>
                                    <tr>
                                        <td>3</td>
                                        <td>Contador</td>
                                        <td>Contabilidade</td>
                                        <td colspan="2">
                                            <a class="btn btn-info btn-sm" href="/cargos/editar/3" role="button">
                                                <span class="oi oi-brush" title="Editar" aria-hidden="true"></span>
                                            </a>
                                            <button type="button" class="btn btn-danger btn-sm" >
                                                <span class="oi oi-circle-x" title="Exclusão desabilitada" aria-hidden="true"></span>
                                            </button>
                                        </td>
                                    </tr>
                                    <tr>
                                        <td>4</td>
                                        <td>Adminitrador</td>
                                        <td>Administração</td>
                                        <td colspan="2">
                                            <a class="btn btn-info btn-sm" href="/cargos/editar/4" role="button">
                                                <span class="oi oi-brush" title="Editar" aria-hidden="true"></span>
                                            </a>
                                            <button type="button" class="btn btn-danger btn-sm" >
                                                <span class="oi oi-circle-x" title="Exclusão desabilitada" aria-hidden="true"></span>
                                            </button>
                                        </td>
                                    </tr>
                                    <tr>
                                        <td>5</td>
                                        <td>Programado PHP</td>
                                        <td>Tecnologia da Informação</td>
                                        <td colspan="2">
                                            <a class="btn btn-info btn-sm" href="/cargos/editar/5" role="button">
                                                <span class="oi oi-brush" title="Editar" aria-hidden="true"></span>
                                            </a>
                                            <button type="button" class="btn btn-danger btn-sm" >
                                                <span class="oi oi-circle-x" title="Exclusão desabilitada" aria-hidden="true"></span>
                                            </button>
                                        </td>
                                    </tr>
                                    <tr>
                                        <td>6</td>
                                        <td>Desenvolvedor Java Jr.</td>
                                        <td>Tecnologia da Informação</td>
                                        <td colspan="2">
                                            <a class="btn btn-info btn-sm" href="/cargos/editar/6" role="button">
                                                <span class="oi oi-brush" title="Editar" aria-hidden="true"></span>
                                            </a>
                                            <button type="button" class="btn btn-danger btn-sm" >
                                                <span class="oi oi-circle-x" title="Exclusão desabilitada" aria-hidden="true"></span>
                                            </button>
                                        </td>
                                    </tr>
                                    <tr>
                                        <td>7</td>
                                        <td>Desenvolvedor Java Pleno</td>
                                        <td>Tecnologia da Informação</td>
                                        <td colspan="2">
                                            <a class="btn btn-info btn-sm" href="/cargos/editar/7" role="button">
                                                <span class="oi oi-brush" title="Editar" aria-hidden="true"></span>
                                            </a>
                                            <button type="button" class="btn btn-danger btn-sm" >
                                                <span class="oi oi-circle-x" title="Exclusão desabilitada" aria-hidden="true"></span>
                                            </button>
                                        </td>
                                    </tr>
                                    <tr>
                                        <td>8</td>
                                        <td>Desenvolvedor Java Senior</td>
                                        <td>Tecnologia da Informação</td>
                                        <td colspan="2">
                                            <a class="btn btn-info btn-sm" href="/cargos/editar/8" role="button">
                                                <span class="oi oi-brush" title="Editar" aria-hidden="true"></span>
                                            </a>
                                            <button type="button" class="btn btn-danger btn-sm" >
                                                <span class="oi oi-circle-x" title="Exclusão desabilitada" aria-hidden="true"></span>
                                            </button>
                                        </td>
                                    </tr>
                                    <tr>
                                        <td>9</td>
                                        <td>Auxiliar de RH</td>
                                        <td>Recursos Humanos</td>
                                        <td colspan="2">
                                            <a class="btn btn-info btn-sm" href="/cargos/editar/9" role="button">
                                                <span class="oi oi-brush" title="Editar" aria-hidden="true"></span>
                                            </a>
                                            <button type="button" class="btn btn-danger btn-sm" >
                                                <span class="oi oi-circle-x" title="Exclusão desabilitada" aria-hidden="true"></span>
                                            </button>
                                        </td>
                                    </tr>
                                    <tr>
                                        <td>10</td>
                                        <td>Coordenador de RH</td>
                                        <td>Recursos Humanos</td>
                                        <td colspan="2">
                                            <a class="btn btn-info btn-sm" href="/cargos/editar/10" role="button">
                                                <span class="oi oi-brush" title="Editar" aria-hidden="true"></span>
                                            </a>
                                            <button type="button" class="btn btn-danger btn-sm" >
                                                <span class="oi oi-circle-x" title="Exclusão desabilitada" aria-hidden="true"></span>
                                            </button>
                                        </td>
                                    </tr>
                                    <tr>
                                        <td>11</td>
                                        <td>Psicologo</td>
                                        <td>Recursos Humanos</td>
                                        <td colspan="2">
                                            <a class="btn btn-info btn-sm" href="/cargos/editar/11" role="button">
                                                <span class="oi oi-brush" title="Editar" aria-hidden="true"></span>
                                            </a>
                                            <button type="button" class="btn btn-danger btn-sm" >
                                                <span class="oi oi-circle-x" title="Exclusão desabilitada" aria-hidden="true"></span>
                                            </button>
                                        </td>
                                    </tr>
                                    </tbody>
                                </table>
                            </div>
                        </div>
                        
                    </section>


            </body>
            </html>		

        Atualização da página templates/cargo/cadastro.html

            <!DOCTYPE html>
            <html layout:decorate="~{layout}">
            <head>
                <meta charset="UTF-8"/>
            </head>
            <body>
                    <section class="layout-content" layout:fragment="corpo">
                
                        <nav class="navbar navbar-expand-md bg-light">
                            <div class="collapse navbar-collapse" id="navbarsExampleDefault">
                                <ul class="navbar-nav mr-auto">
                                    <li class="nav-item active">
                                        <i class="oi oi-caret-right"></i>
                                        <span>Cadastrar Cargos</span>
                                    </li>
                                </ul>
                            </div>
                            <a class="btn btn-primary btn-md" href="/cargos/listar" role="button">
                                <span class="oi oi-spreadsheet" title="Cadastro" aria-hidden="true"></span>
                                <span>Listar Cargos</span>
                            </a>
                        </nav>
                
                        <div class="container" id="cadastro">
                            <form action="/cargos/salvar" method="POST">
                                <div class="form-row">
                                    <div class="form-group col-md-6">
                                        <label for="nome">Nome do Cargo</label>
                                        <input type="text" class="form-control" id="nome" placeholder="Nome Cargo" autofocus="autofocus"
                                            name="nome" value=""/>
                                    </div>
                                    <div class="form-group col-md-4">
                                        <label for="departamento">Departamento</label>
                                        <select id="departamento" class="form-control" name="departamento">
                                            <option value="">Selecione</option>
                                            <option value="3">Administração</option>
                                            <option value="2">Contabilidade</option>
                                            <option value="1">Recursos Humanos</option>
                                            <option value="4">Tecnologia da Informação</option>
                                        </select>
                                    </div>
                                </div>
                                <input type="hidden" id="id" name="id" value=""/>
                                <button type="submit" class="btn btn-primary btn-sm">Salvar</button>
                            </form>
                        </div>
                    </section>


            </body>
            </html>		

        Atualização da página templates/departamento/lista.html

            <!DOCTYPE html>
            <html layout:decorate="~{layout}">
            <head>
                <meta charset="UTF-8"/>
            </head>
            <body>
                
                    <section class="layout-content" layout:fragment="corpo">
                
                        <nav class="navbar navbar-expand-md bg-light">
                            <div class="collapse navbar-collapse" id="navbarsExampleDefault">
                                <ul class="navbar-nav mr-auto">
                                    <li class="nav-item active">
                                        <i class="oi oi-caret-right"></i>
                                        <span>Lista de Departamentos</span>
                                    </li>
                                </ul>
                                <a class="btn btn-primary btn-md" href="/departamentos/cadastrar" role="button">
                                    <span class="oi oi-plus" title="Cadastro" aria-hidden="true"></span>
                                    <span>Novo Departamento</span>
                                </a>
                            </div>
                        </nav>
                
                        <div class="container" id="listagem">
                
                            <div class="table-responsive">
                                <table class="table table-striped table-hover table-sm">
                                    <thead>
                                    <tr>
                                        <th>#</th>
                                        <th>Nome</th>
                                        <th>Ação</th>
                                    </tr>
                                    </thead>
                                    <tbody>
                                    <tr>
                                        <td>3</td>
                                        <td>Administração</td>
                                        <td colspan="2">
                                            <a class="btn btn-info btn-sm" href="/departamentos/editar/3" role="button">
                                                <span class="oi oi-brush" title="Editar" aria-hidden="true"></span>
                                            </a>
                                            <button id="btn_departamentos/excluir/3" type="button" class="btn btn-danger btn-sm">
                                                <span class="oi oi-circle-x" title="Exclusão desabilitada" aria-hidden="true"></span>
                                            </button>
                                        </td>
                                    </tr>
                                    <tr>
                                        <td>2</td>
                                        <td>Contabilidade</td>
                                        <td colspan="2">
                                            <a class="btn btn-info btn-sm" href="/departamentos/editar/2" role="button">
                                                <span class="oi oi-brush" title="Editar" aria-hidden="true"></span>
                                            </a>
                                            <button type="button" class="btn btn-danger btn-sm">
                                                <span class="oi oi-circle-x" title="Exclusão desabilitada" aria-hidden="true"></span>
                                            </button>
                                        </td>
                                    </tr>
                                    <tr>
                                        <td>1</td>
                                        <td>Recursos Humanos</td>
                                        <td colspan="2">
                                            <a class="btn btn-info btn-sm" href="/departamentos/editar/1" role="button">
                                                <span class="oi oi-brush" title="Editar" aria-hidden="true"></span>
                                            </a>
                                            <button type="button" class="btn btn-danger btn-sm" >
                                                <span class="oi oi-circle-x" title="Exclusão desabilitada" aria-hidden="true"></span>
                                            </button>
                                        </td>
                                    </tr>
                                    <tr>
                                        <td>4</td>
                                        <td>Tecnologia da Informação</td>
                                        <td colspan="2">
                                            <a class="btn btn-info btn-sm" href="/departamentos/editar/4" role="button">
                                                <span class="oi oi-brush" title="Editar" aria-hidden="true"></span>
                                            </a>
                                            <button type="button" class="btn btn-danger btn-sm" >
                                                <span class="oi oi-circle-x" title="Exclusão desabilitada" aria-hidden="true"></span>
                                            </button>
                                        </td>
                                    </tr>
                                    </tbody>
                                </table>
                            </div>
                        </div>
                    </section>
            </body>
            </html>		

        Atualização da página templates/departamento/cadastro.html

            <!DOCTYPE html>
            <html layout:decorate="~{layout}">
            <head>
                <meta charset="UTF-8"/>
            </head>
            <body>
                
                    <section class="layout-content" layout:fragment="corpo">
                
                        <nav class="navbar navbar-expand-md bg-light">
                            <div class="collapse navbar-collapse" id="navbarsExampleDefault">
                                <ul class="navbar-nav mr-auto">
                                    <li class="nav-item active">
                                        <i class="oi oi-caret-right"></i>
                                        <span>Cadastrar Departamentos</span>
                                    </li>
                                </ul>
                                <a class="btn btn-primary btn-md" href="/departamentos/listar" role="button">
                                    <span class="oi oi-spreadsheet" title="Listar" aria-hidden="true"></span>
                                    <span>Listar Departamentos</span>
                                </a>
                            </div>
                        </nav>
                
                        <div class="container" id="cadastro">
                            <form action="/departamentos/salvar" method="POST">
                                <div class="form-row">
                                    <div class="form-group col-md-6">
                                        <label for="nome">Departamento</label>
                                        <input type="text" class="form-control" id="nome"
                                            placeholder="Nome Departamento" autofocus="autofocus" name="nome" value=""/>
                                    </div>
                                </div>
                                <input type="hidden" id="id" name="id" value=""/>
                                <button type="submit" class="btn btn-primary btn-sm">Salvar</button>
                            </form>
                        </div>
                    </section>
            </body>
            </html>

        Atualização da página templates/funcionarios/lista.html

            <!DOCTYPE html>
            <html layout:decorate="~{layout}">
            <head>
                <meta charset="UTF-8"/>
            </head>
            <body>
                
                    <section class="layout-content" layout:fragment="corpo">
                        <nav class="navbar navbar-expand-md bg-light">
                            <div class="collapse navbar-collapse" id="navbarsExampleDefault">
                                <ul class="navbar-nav mr-auto">
                                    <li class="nav-item active">
                                        <i class="oi oi-caret-right"></i>
                                        <span>Lista de Funcionários</span>
                                    </li>
                                </ul>
                                <a class="btn btn-primary btn-md" href="/funcionarios/cadastrar" role="button">
                                    <span class="oi oi-plus" title="Cadastro" aria-hidden="true"></span>
                                    <span>Cadastrar Funcionários</span>
                                </a>
                            </div>
                        </nav>
                
                        <div class="container">
                
                            <p>
                                <i class="oi oi-magnifying-glass"></i><span></span>
                                <button class="btn btn-primary" type="button" data-toggle="collapse" data-target="#collapseNome"
                                        aria-controls="collapseNome">Nome
                                </button>
                                <button class="btn btn-primary" type="button" data-toggle="collapse" data-target="#collapseCargo"
                                        aria-controls="collapseCargo">Cargo
                                </button>
                                <button class="btn btn-primary" type="button" data-toggle="collapse" data-target="#collapseData"
                                        aria-controls="collapseData">Datas
                                </button>
                            </p>
                            <div class="row">
                                <div class="col">
                                    <div class="collapse" id="collapseNome">
                
                                        <nav class="navbar navbar-light bg-light">
                                            <form class="form-inline" method="GET" action="/funcionarios/buscar/nome">
                                                <input class="form-control mr-sm-2" type="search" placeholder="nome" aria-label="Search"
                                                    name="nome" />
                                                <button class="btn btn-outline-success my-2 my-sm-0">Search</button>
                                            </form>
                                        </nav>
                
                                    </div>
                                </div>
                            </div>
                            <div class="row">
                                <div class="col">
                                    <div class="collapse" id="collapseCargo">
                
                                        <nav class="navbar navbar-light bg-light">
                                            <form class="form-inline" method="GET" action="/funcionarios/buscar/cargo">
                                                <select class="form-control mr-sm-2" name="cargo" aria-label="Search">
                                                    <option value="">Cargo</option>
                                                    <option value="1">Auxiliar Contábil</option>
                                                    <option value="2">Auxiliar Administrativo</option>
                                                    <option value="3">Contador</option>
                                                    <option value="4">Adminitrador</option>
                                                    <option value="5">Programado PHP</option>
                                                    <option value="6">Desenvolvedor Java Jr.</option>
                                                    <option value="7">Desenvolvedor Java Pleno</option>
                                                    <option value="8">Desenvolvedor Java Senior</option>
                                                    <option value="9">Auxiliar de RH</option>
                                                    <option value="10">Coordenador de RH</option>
                                                    <option value="11">Psicologo</option>
                                                </select>
                                                <button class="btn btn-outline-success my-2 my-sm-0">Search</button>
                                            </form>
                                        </nav>
                
                                    </div>
                                </div>
                            </div>
                            <div class="row">
                                <div class="col">
                                    <div class="collapse" id="collapseData">
                
                                        <nav class="navbar navbar-light bg-light">
                                            <form class="form-inline" method="GET" action="/funcionarios/buscar/data">
                                                <input class="form-control mr-sm-2" type="date" aria-label="Search"
                                                    name="entrada" />
                                                <input class="form-control mr-sm-2" type="date" aria-label="Search"
                                                    name="saida" />
                                                <button class="btn btn-outline-success my-2 my-sm-0">Search</button>
                                            </form>
                                        </nav>
                
                                    </div>
                                </div>
                            </div>
                
                
                            <div class="table-responsive">
                                <table class="table table-striped table-hover table-sm">
                                    <thead>
                                    <tr>
                                        <th>#</th>
                                        <th>Nome</th>
                                        <th>Salário</th>
                                        <th>Departamento</th>
                                        <th>Cargo</th>
                                        <th>Endereço</th>
                                        <th>Data de Entrada</th>
                                        <th>Data de Saída</th>
                                        <th>Ação</th>
                                    </tr>
                                    </thead>
                                    <tbody>
                                    <tr>
                                        <td>1</td>
                                        <td>Jorge da Silva</td>
                                        <td>R$ 3.500,99</td>
                                        <td>Recursos Humanos</td>
                                        <td>Auxiliar de RH</td>
                                        <td>
                                            <button type="button" class="btn btn-secondary btn-sm" data-container="body"
                                                    data-toggle="popover" data-placement="top"
                                                    data-content="Rua das Oliveiras, 260 Fundos - Centro, Porto Alegre - RS - 97050-015">
                                                <span class="oi oi-eye" title="Visualizar" aria-hidden="true"></span>
                                            </button>
                                        </td>
                                        <td>01/10/2014</td>
                                        <td></td>
                                        <td colspan="2">
                                            <a class="btn btn-info btn-sm" href="/funcionarios/editar/1" role="button">
                                                <span class="oi oi-brush" title="Editar" aria-hidden="true"></span>
                                            </a>
                                            <button id="btn_funcionarios/excluir/1" type="button" class="btn btn-danger btn-sm"
                                                    data-toggle="modal" data-target="#myModal">
                                                <span class="oi oi-circle-x" title="Excluir" aria-hidden="true"></span>
                                            </button>
                                        </td>
                                    </tr>
                                    <tr>
                                        <td>2</td>
                                        <td>Ana Maria Lindoval</td>
                                        <td>R$ 3.560,70</td>
                                        <td>Administração</td>
                                        <td>Auxiliar Administrativo</td>
                                        <td>
                                            <button type="button" class="btn btn-secondary btn-sm" data-container="body"
                                                    data-toggle="popover" data-placement="top"
                                                    data-content="Av. dos Palmares, 320  - Ribeirão, Canoas - RS - 98050-908">
                                                <span class="oi oi-eye" title="Visualizar" aria-hidden="true"></span>
                                            </button>
                                        </td>
                                        <td>01/08/2014</td>
                                        <td>02/03/2015</td>
                                        <td colspan="2">
                                            <a class="btn btn-info btn-sm" href="/funcionarios/editar/2" role="button">
                                                <span class="oi oi-brush" title="Editar" aria-hidden="true"></span>
                                            </a>
                                            <button id="btn_funcionarios/excluir/2" type="button" class="btn btn-danger btn-sm"
                                                    data-toggle="modal" data-target="#myModal">
                                                <span class="oi oi-circle-x" title="Excluir" aria-hidden="true"></span>
                                            </button>
                                        </td>
                                    </tr>
                                    <tr>
                                        <td>3</td>
                                        <td>Juan Perez</td>
                                        <td>R$ 4.060,99</td>
                                        <td>Tecnologia da Informação</td>
                                        <td>Desenvolvedor Java Jr.</td>
                                        <td>
                                            <button type="button" class="btn btn-secondary btn-sm" data-container="body"
                                                    data-toggle="popover" data-placement="top"
                                                    data-content="Rua Senador Cassiano do Nascimento, 135 AP. 106 - Noroeste, Porto Alegre - RS - 90798-099">
                                                <span class="oi oi-eye" title="Visualizar" aria-hidden="true"></span>
                                            </button>
                                        </td>
                                        <td>05/01/2015</td>
                                        <td></td>
                                        <td colspan="2">
                                            <a class="btn btn-info btn-sm" href="/funcionarios/editar/3" role="button">
                                                <span class="oi oi-brush" title="Editar" aria-hidden="true"></span>
                                            </a>
                                            <button id="btn_funcionarios/excluir/3" type="button" class="btn btn-danger btn-sm"
                                                    data-toggle="modal" data-target="#myModal">
                                                <span class="oi oi-circle-x" title="Excluir" aria-hidden="true"></span>
                                            </button>
                                        </td>
                                    </tr>
                                    <tr>
                                        <td>4</td>
                                        <td>Marcio Silva</td>
                                        <td>R$ 2.890,99</td>
                                        <td>Contabilidade</td>
                                        <td>Auxiliar Contábil</td>
                                        <td>
                                            <button type="button" class="btn btn-secondary btn-sm" data-container="body"
                                                    data-toggle="popover" data-placement="top"
                                                    data-content="Av. Maracanã, 309 AP. 108 - Maracanã, Rio de Janeiro - RJ - 91050-980">
                                                <span class="oi oi-eye" title="Visualizar" aria-hidden="true"></span>
                                            </button>
                                        </td>
                                        <td>18/10/2013</td>
                                        <td>06/09/2015</td>
                                        <td colspan="2">
                                            <a class="btn btn-info btn-sm" href="/funcionarios/editar/4" role="button">
                                                <span class="oi oi-brush" title="Editar" aria-hidden="true"></span>
                                            </a>
                                            <button id="btn_funcionarios/excluir/4" type="button" class="btn btn-danger btn-sm"
                                                    data-toggle="modal" data-target="#myModal">
                                                <span class="oi oi-circle-x" title="Excluir" aria-hidden="true"></span>
                                            </button>
                                        </td>
                                    </tr>
                                    <tr>
                                        <td>5</td>
                                        <td>Joana Prado</td>
                                        <td>R$ 3.804,00</td>
                                        <td>Recursos Humanos</td>
                                        <td>Coordenador de RH</td>
                                        <td>
                                            <button type="button" class="btn btn-secondary btn-sm" data-container="body"
                                                    data-toggle="popover" data-placement="top"
                                                    data-content="Rua Gomes Carneiro, 909  - Centro, Porto Alegre - RS - 98080-999">
                                                <span class="oi oi-eye" title="Visualizar" aria-hidden="true"></span>
                                            </button>
                                        </td>
                                        <td>01/05/2015</td>
                                        <td></td>
                                        <td colspan="2">
                                            <a class="btn btn-info btn-sm" href="/funcionarios/editar/5" role="button">
                                                <span class="oi oi-brush" title="Editar" aria-hidden="true"></span>
                                            </a>
                                            <button id="btn_funcionarios/excluir/5" type="button" class="btn btn-danger btn-sm"
                                                    data-toggle="modal" data-target="#myModal">
                                                <span class="oi oi-circle-x" title="Excluir" aria-hidden="true"></span>
                                            </button>
                                        </td>
                                    </tr>
                                    </tbody>
                                </table>
                            </div>
                        </div>
                    </section>
            </body>
            </html>		

        Atualização da página templates/funcionarios/cadastro.html

            <!DOCTYPE html>
            <html layout:decorate="~{layout}">
            <head>
                <meta charset="UTF-8"/>
            </head>
            <body>
                
                    <section class="layout-content" layout:fragment="corpo">
                        <div class="page-header">
                            <nav class="navbar navbar-expand-md navbar-top bg-light">
                                <div class="collapse navbar-collapse" id="navbarsExampleDefault">
                                    <ul class="navbar-nav">
                                        <li class="nav-item active">
                                            <i class="oi oi-caret-right"></i>
                                            <span>Cadastrar Funcionários</span>
                                        </li>
                                    </ul>
                                </div>
                                <a class="btn btn-primary btn-md" href="/funcionarios/listar" role="button">
                                    <span class="oi oi-spreadsheet" title="Cadastro" aria-hidden="true"></span>
                                    <span>Listar Funcionários</span>
                                </a>
                            </nav>
                        </div>
                
                        <div class="container" id="cadastro">
                            <form action="/funcionarios/salvar" method="POST">
                                <div class="form-row">
                                    <div class="form-group col-md-6">
                                        <label for="nome">Nome do Funcionário</label>
                                        <input type="text" class="form-control" id="nome" placeholder="Nome Completo"
                                            autofocus="autofocus" name="nome" value=""/>
                                        <div class="invalid-feedback">
                
                                        </div>
                                    </div>
                                    <div class="form-group col-md-6">
                                        <label for="salario">Salário Bruto</label>
                                        <input type="text" class="form-control" id="salario" data-mask="#.##0,00"
                                            data-mask-reverse="true" name="salario" value=""/>
                                        <div class="invalid-feedback">
                
                                        </div>
                                    </div>
                                </div>
                                <div class="form-row">
                                    <div class="form-group col-md-6">
                                        <label for="dataEntrada">Data de Entrada</label>
                                        <input type="date" class="form-control" id="dataEntrada" name="dataEntrada" value=""/>
                                        <div class="invalid-feedback">
                
                                        </div>
                                    </div>
                                    <div class="form-group col-md-6">
                                        <label for="dataSaida">Data de Saída</label>
                                        <input type="date" class="form-control" id="dataSaida" name="dataSaida" value=""/>
                                        <div class="invalid-feedback">
                
                                        </div>
                                    </div>
                                </div>
                                <div class="form-row">
                                    <div class="form-group col-md-6">
                                        <label for="cargo">Cargo</label>
                                        <select id="cargo" class="form-control" name="cargo">
                                            <option value="">Selecione...</option>
                                            <option value="1">Auxiliar Contábil</option>
                                            <option value="2">Auxiliar Administrativo</option>
                                            <option value="3">Contador</option>
                                            <option value="4">Adminitrador</option>
                                            <option value="5">Programado PHP</option>
                                            <option value="6">Desenvolvedor Java Jr.</option>
                                            <option value="7">Desenvolvedor Java Pleno</option>
                                            <option value="8">Desenvolvedor Java Senior</option>
                                            <option value="9">Auxiliar de RH</option>
                                            <option value="10">Coordenador de RH</option>
                                            <option value="11">Psicologo</option>
                                        </select>
                                        <div class="invalid-feedback">
                
                                        </div>
                                    </div>
                                </div>
                                <div class="form-row">
                                    <div class="form-group col-md-6">
                                        <label for="cidade">Cidade</label>
                                        <input type="text" class="form-control" id="cidade" name="endereco.cidade" value=""/>
                                        <div class="invalid-feedback">
                
                                        </div>
                                    </div>
                                    <div class="form-group col-md-6">
                                        <label for="logradouro">Logradouro</label>
                                        <input type="text" class="form-control" id="logradouro" placeholder="logradouro sem número"
                                            name="endereco.logradouro" value=""/>
                                        <div class="invalid-feedback">
                
                                        </div>
                                    </div>
                                </div>
                                <div class="form-row">
                                    <div class="form-group col-md-6">
                                        <label for="numero">Número</label>
                                        <input type="text" class="form-control" id="numero" name="endereco.numero" value=""/>
                                        <div class="invalid-feedback">
                
                                        </div>
                                    </div>
                                    <div class="form-group col-md-6">
                                        <label for="complemento">Complemento</label>
                                        <input type="text" class="form-control" id="complemento" placeholder="fundos, casa, AP. 102, .."
                                            name="endereco.complemento" value=""/>
                                        <div class="invalid-feedback">
                
                                        </div>
                                    </div>
                                </div>
                                <div class="form-row">
                                    <div class="form-group col-md-6">
                                        <label for="bairro">Bairro</label>
                                        <input type="text" class="form-control" id="bairro" name="endereco.bairro" value=""/>
                                        <div class="invalid-feedback">
                
                                        </div>
                                    </div>
                                    <div class="form-group col-md-4">
                                        <label for="uf">UF</label>
                                        <select id="uf" class="form-control" name="endereco.uf">
                                            <option value="">Selecione...</option>
                                            <option value="AC">AC</option>
                                            <option value="AL">AL</option>
                                            <option value="AM">AM</option>
                                            <option value="BA">BA</option>
                                            <option value="CE">CE</option>
                                            <option value="DF">DF</option>
                                            <option value="ES">ES</option>
                                            <option value="GO">GO</option>
                                            <option value="MA">MA</option>
                                            <option value="MT">MT</option>
                                            <option value="MS">MS</option>
                                            <option value="MG">MG</option>
                                            <option value="PA">PA</option>
                                            <option value="PB">PB</option>
                                            <option value="PR">PR</option>
                                            <option value="PE">PE</option>
                                            <option value="PI">PI</option>
                                            <option value="RJ">RJ</option>
                                            <option value="RN">RN</option>
                                            <option value="RS">RS</option>
                                            <option value="RO">RO</option>
                                            <option value="RR">RR</option>
                                            <option value="SC">SC</option>
                                            <option value="SP">SP</option>
                                            <option value="SE">SE</option>
                                            <option value="TO">TO</option>
                                        </select>
                                        <div class="invalid-feedback">
                
                                        </div>
                                    </div>
                                    <div class="form-group col-md-2">
                                        <label for="cep">Cep</label>
                                        <input type="text" class="form-control" id="cep" data-mask="00000-000" name="endereco.cep"
                                            value=""/>
                                        <div class="invalid-feedback">
                
                                        </div>
                                    </div>
                                </div>
                                <input type="hidden" id="id" name="id" value=""/>
                                <button type="submit" class="btn btn-primary btn-sm">Salvar</button>
                            </form>
                        </div>
                    </section>

            </body>
            </html>		


${...} : Variable expressions.
*{...} : Selection expressions.
#{...} : Message (i18n) expressions.
@{...} : Link (URL) expressions.
~{...} : Fragment expressions.


Aulas 36 a 42 - Departamento Controller & View
----------------------------------------------

. Componentes do Thymeleaf

    O Thymeleaf tem uma lista com vários componentes que podem ser incluídos nas páginas 
    para a realização de diversas ações. Alguns destes componentes serão abordados no 
    curso para o uso em formulários de cadastros e listagem de dados.

    Entre estes, podemos destacar os seguintes:

        th:action - substitui o atributo action padrão do HTML. Desta forma é possível usar uma 
                    expressão do tipo @{/departamento/save} contendo como valor a URI de destino.
        th:href - substitui o atributo href padrão do HTML para o uso de URIs ou URLs. 
                    A expressão declarado como valor deste componente é @{/departamento/save}.
        th:object - o componente deve receber como valor uma expressão contendo o objeto que 
                    representa a entidade que está sendo manipulada pelo formulário: ${departamento}
        th:field - seu objetivo é ser usado em campos de entrada de dados em formulários 
                    para que ele capture dos dados lançados no campo e vincule esses dados 
                    com o objeto declarado na expressão do th:object. O valor de th:field deve 
                    ser uma expressão do tipo *{nome} onde o valor da expressão é o nome do 
                    atributo da classe de entidade que o campo do formulário representa.
        th:text - usado para exibir valores nas páginas.
        th:if - util para realizar algum tipo de teste condicional do tipo se.
        th:each - sua função é executar uma instrução de foreach sobre uma variável que tem 
                    como valor uma lista de dados.

    Outros componentes podem ser encontrados na documentação oficial do 

    Thymeleaf - https://www.thymeleaf.org/doc/tutorials/3.0/usingthymeleaf.html#setting-value-to-specific-attributes

    Veja a seguir um trecho de código que demonstra como trabalhar com uma lista junto 
    ao th:each para criar uma tabela na página:

    <table class="table table-striped table-hover table-sm">
    <thead>
    <tr>
        <th>#</th>
        <th>Nome</th>
        <th>Ação</th>
    </tr>
    </thead>
    <tbody>
    <tr th:each="d : ${departamentos}">
        <td th:text="${d.id}">3</td>
        <td th:text="${d.nome}">Administração</td>
        <td colspan="2">
            <button th:href="@{/departamentos/editar/{id} (id=${d.id}) }">
                <span class="oi oi-brush" title="Editar"></span>
            </button >
            <button th:href="@{/departamentos/excluir/{id} (id=${d.id}) }">
                <span class="oi oi-circle-x" title="Excluir"></span>
            </button>
        </td>
    </tr>
    </tbody>
    </table>

    No th:each declaramos uma expressão onde o valor mais a esquerda é a variável que vai 
    receber o valor do objeto na posição atual do foreach. Já o valor mais a direita é a 
    expressão padrão do Java para recuperar valores que estão no contexto da aplicação. 
    Esta expressão contém a variável departamentos que é uma lista de departamento do 
    tipo java.util.List.

    Esta lista foi enviada para a página pelo controller, com um método similar ao descrito a seguir:

    @GetMapping("/listar")
    public String listar(ModelMap model) {
        List<Departamento> listDeparts = service.buscarTodos();
        model.addAttribute("departamentos", listDeparts);
        return "/departamento/lista"; 
    }

    Observe que a instrução model.addAttribute() possui dois parâmetros. O primeiro é o 
    nome da variável que espera pela lista na página. O segundo é a própria lista que será 
    enviada como valor desta variável.

    Outros componentes estão exemplificados no código HTML da tabela. Como exemplo, o th:text 
    que imprime nas colunas os respectivos valores capturados a partir da variável d, que 
    representa um objeto do tipo Departamento.

    <td th:text="${d.id}">3</td>

    Já o th:href está declarado nos botões de Editar e Excluir. 
    Este componente recebe como valor a expressão que possui como a URI de destino de cada botão.

    Veja com atenção como o valor do identificador de um departamento foi incluído nas URIs.

    <button th:href="@{/departamentos/excluir/{id} (id=${d.id}) }" type="button" class="btn btn-danger btn-sm">

    Na URI a expressão {id} foi adicionada como o path que vai conter o valor do 
    identificador que deve ser levado até o controller. Mas para que essa expressão 
    contenha o valor do identificador, foi usado um recurso do Thymeleaf para captura-lo 
    a partir da variável d e atribui-lo a expressão. Esse recurso é (id=${d.id}) onde id 
    é a variável que representa o valor da expressão {id}. E essa variável é atribuída 
    pelo valor da variável ${d.id}.

    Já o th:action, th:object e th:field têm seu uso descrito logo a seguir:

    <form th:action="@{/departamentos/salvar}" 
        th:object="${departamento}" method="POST">
        <div class="form-row">
            <div class="form-group col-md-6">
                <label for="nome">Departamento</label>
                <input th:field="*{nome}" type="text" id="nome" />
            </div>
        </div>
        <input type="hidden" id="id" th:field="*{id}"/>
        <button type="submit" class="btn btn-primary>Salvar</button>
    </form>

    No formulário apresentado, o th:action e o th:object são incluídos na tag form. 
    Já o th:field foi incluído nas tags de input.

    No código a seguir, veja o uso do componente th:if.

    <div th:if="${success} != null">
        <div class="alert alert-success alert-dismissible fade show" role="alert">
        <i class="oi oi-check"></i>
        <span>
            <strong th:text="${success}"></strong> 
        </span>
        </div>
    </div>

    Este componente recebe como valor a variável success, envida pelo controller. 
    O th:if testa então se a condição ${success != null} é verdadeira. 
    Caso seja, o <div> será incluído na página. Caso a condição seja falsa,
    o <div> não será incluído na página. Ou seja, o th:if garante que a tag só 
    seja visível na página se a condição for verdadeira, caso contrário o <div> 
    será omitido.



Aulas 43 a 48 - Cargo - Controller e View
-----------------------------------------

Convertendo objetos

Algumas vezes ao trabalhar com o Spring MVC será necessário converter alguns 
tipos de objetos que são enviados da página para o controller. Podemos dizer 
que existem dois tipos de objetos, os objetos simples e os complexos. Objetos 
simples são aqueles como String, Long, Integer, entre outros, onde apenas se 
atribuí um único valor. Já objetos complexos são aqueles que contém outros 
objetos internamente, como as classes de entidades. Classes de entidades podem 
ter objetos simples na forma de atributos como também, objetos complexos.

Na classe Cargo, além do id (Long) e nome (String), temos um objeto complexo 
que é o Departamento. Outra classe de entidade que possui internamente 
outros tipos de objetos.

Sendo assim, veja o código a seguir que exemplifica na página a criação de 
um combobox no formulário para cadastro de cargos:

    <form th:action="${@{/cargos/editar}" th:object="${cargo}" method="POST">
        <div class="form-row">
            <div class="form-group col-md-6">
                <label for="nome">Nome do Cargo</label>
                <input type="text" id="nome" th:field="*{nome}"/>
            </div>
            <div class="form-group col-md-4">
                <label for="departamento">Departamento</label>
                <select id="departamento" class="form-control" th:field="*{departamento}">
                    <option value="">Selecione</option>
                    <option th:each="d : ${departamentos}" 
                            th:value="${d.id}" th:text="${d.nome}"></option>
                </select>
            </div>
        </div>
        <input type="hidden" id="id" th:field="*{id}"/>
        <button type="submit">Salvar</button>
    </form>

O código contido na tag select representa a criação do combobox 
que vai listar os departamentos cadastrados. Nessa tag temos o 
componente th:field que deverá enviar para o controller um objeto 
departamento como parte do objeto cargo. Porém, em o componente do 
Thymeleaf th:value foi setado com o valor d.id, ou seja, com o valor 
do identificador do departamento selecionado no combobox.

Esse id acaba sendo enviado pelo formulário para o controller, porém, o 
controller espera por um objeto departamento. Nesse caso, a operação vai 
resultar em um exceção com a mensagem a seguir:

    Field error in object 'cargo' on field 'departamento': rejected value [2]; 
    codes [typeMismatch.cargo.departamento,
    typeMismatch.departamento,
    typeMismatch.com.mballem.curso.boot.domain.Departamento,
    typeMismatch]; 
    arguments [org.springframework.context.support.DefaultMessageSourceResolvable: 
    codes [cargo.departamento,departamento]; arguments []; 
    default message [departamento]]; 
    default message [Failed to convert property value of type 'java.lang.String' to 
                     required type 'com.mballem.curso.boot.domain.Departamento' 
                     for property 'departamento'; 
    nested exception is java.lang.IllegalStateException: 
    Cannot convert value of type 'java.lang.String' to required 
    type 'com.mballem.curso.boot.domain.Departamento' 
    for property 'departamento': no matching editors or conversion strategy found]

Esta exceção está dizendo que ouve um erro na operação, já que a operação esperava por 
um objeto departamento sendo enviado para cargo, porém recebeu um objeto String. 
Este objeto String é o valor do id selecionado no combobox.

Para resolver este erro, o Spring fornece a interface 
org.springframework.core.convert.converter.Converter para que possamos 
trabalhar na conversão do id em um departamento. Esta interface deve ser 
implementada em um classe, a qual o Spring vai interceptar toda 
vez que CargoController for acessado por uma requisição:

    <code>@Component
    public class StringToDepartamentoConverter implements Converter<String, Departamento> {        
        @Autowired
        private DepartamentoService service;
    
        @Override
        public Departamento convert(String text) {
            if (text.isEmpty()) {
                return null;
            }
            Long id = Long.valueOf(text);
            return service.buscarPorId(id);
        }    
    }
    </code>

A classe StringToDepartamentoConverter implementa a interface Converter e como valor 
genérico essa interface recebe um String e um Departamento. O Spring é para informar 
o tipo de dado que será recebido da página. No caso, o id vem da página na forma de 
um String. Já o Departamento é para informar qual o tipo de dado que será criado 
após a conversão.

No método convert(), da interface Converter, o argumento de sua assinatura é o valor 
recebido da página. Aquele selecionado lá no combobox.

Para realizar a conversão precisamos primeiro transformar o valor de text 
em um Long, para então, usar o valor do id selecionado na página como parâmetro 
da consulta que vai localizar no banco de dados o departamento referente a este 
identificador.

Para realizar a consulta no banco vamos trabalhar com a injeção de interface 
DepartamentoService para acessar o método buscarPorId(). O retorno desta operação 
será um objeto departamento que vai então ser atribuído ao objeto cargo esperado 
pelo controller. Assim, não haverá nenhum erro na operação de cadastro de um cargo.

. Expressão utilitária do Thymeleaf

O Thymeleaf possui uma lista de expressões utilitárias as quais têm vários 
métodos que podem ser usados nas páginas para vários tipos de operações como 
formatação, concatenação, entre outros.

Um exemplo desse tipo de expressão é a #strings a qual pode ser usada para 
concatenar textos, como o exemplo a seguir:

<button th:id="${#strings.concat('btn_cargos/excluir/', c.id)  }">
    <span class="oi oi-circle-x" aria-hidden="true"></span>
</button>

Veja no componente th:id que a expressão #strings foi adicionada dentro da 
expressão ${}. Assim, você terá acesso a uma lista de métodos para manipulação 
de strings, muito similares aqueles da classe java.lang.String.

No caso apresentado, o método utilizado foi o concat(), para realizar a 
concatenação da URL com o valor do identificador. Cada string deve ser adicionada 
como um parâmetro do método concat() e dessa forma, os parâmetro serão 
concatenados em uma única string.

Para conhecer mais métodos utilitários da expressão #string, acesse a 
documentação do Thymeleaf:

Strings - https://www.thymeleaf.org/doc/tutorials/3.0/usingthymeleaf.html#strings




Aulas 49 a 56 - Funcionario: Controller and View
------------------------------------------------

Para trabalharmos com o formulário de cadastro de funcionários será necessário adicionar 
no lado servidor da aplicação três conversores de dados. Um deles, será para o identificador 
do cargo selecionado no combobox. Esse identificador deve ser convertido em um objeto 
do tipo Cargo para que o Spring MVC insira esse cargo como valor da variável cargo da 
classe Funcionario. E assim, o método salvar() de FuncionarioController vai poder 
receber os dados do formulário encapsulados na variável funcionario.

Para realizar essa conversão se pode usar a interface Converter do pacote 
org.springframework.core.convert.converter.Converter, como exemplificado a seguir:

    @Component
    public class StringToCargoConversor implements Converter {    
        @Autowired
        private CargoService service;
                
        @Override
        public Cargo convert(String text) {
            if (text.isEmpty()) {
                return null;
            }
            Long id = Long.valueOf(text);
            return service.buscarPorId(id);
        }
    }

Analisando o código podemos verificar que:

@Component - transforma a classe em um bean do Spring, assim, por meio da interface 
Converter o Spring MVC reconhece esse bean e o utiliza para realizar a conversão.

Converter - esta interface fornece o método convert() para implementarmos as regras 
da conversão de tipos. O String, como genérico, representa o tipo de dado que está 
chegado na classe. Já o Cargo indica qual o tipo de dado que deve ser o resultado 
deste processo.

@Autowired - usada para injetar a dependência CargoService, a qual será necessário 
para retornar um objeto cargo por meio do id recebido da página.

convert() - é o método que contém a lógica de conversão de tipos. Ele recebe o valor 
enviado pela página, na forma de um String, e deve retornar um cargo. Para se obter 
esse retorno, usamos o método buscarPorId() da da interface UsuarioService.

A partir do processo apresentado o Spring MVC consegue ter acesso ao objeto cargo 
selecionado pelo usuário no combobox da página de cadastro. A interface Converter 
pode ser usada para a conversão de qualquer tipo de dado, como exemplo, de String 
para LocalDate, de String para BigDecimal, de String para Calendar, entre outros.

Outros três campos do formulário vão precisar de um processo de conversão, são eles, 
os campos para o cadastro de salário, data de entrada e da data de saída. Estes campos 
enviam um tipo String para o controller, porém, a classe Funcionario espera por um 
tipo BigDecimal para o salário e LocalDate para as datas.

Para essas situações a interface Converter serviria perfeitamente para se criar 
as regras de conversões entre estes tipos de dados. Entretanto, o Spring fornece 
duas anotações especificas para essas conversões referentes ao salários e as datas. 
As anotação são:

@NumberFormat - usada para converter valores inseridos na página que deve ser 
transformados em objetos de domínio que representam tipos monetários, porcentagens e 
outros tipos de números em geral.

@DateTimeFormat - transformar e formatar uma data envida pela página em objetos 
java.time.LocalDate, java.util.Date e java.util.Calendar.

Essas anotações devem ser incluídas nas variáveis de destino dos valores enviados pelo 
formulário. No caso do formulário de funcionários, as anotações devem ser incluídas na 
classe Funcionario sobre as devidas variáveis de instancia, como o exemplo a seguir:

    public class Funcionario {
        
        @NumberFormat(style = Style.CURRENCY, pattern = "#,##0.00")
        private BigDecimal salario;
        
        @DateTimeFormat(iso = ISO.DATE)
        private LocalDate dataEntrada;
        
        @DateTimeFormat(iso = ISO.DATE)
        private LocalDate dataSaida;    
    }

Observe que a anotação @NumberFormat tem dois atributos internos. O style recebe o 
tipo de formato desejado que pode ser: Style.CURRENCY, Style.NUMBER e Style.PERCENT. 
Já o atributo pattern é para se definir o padrão de formatação do valor desta variável 
após a conversão.

Nos campos de datas a @DateTimeFormat possui o atributo iso. Este atributo vai indicar 
a conversão o formato desejado da data. As opções são ISO.DATE, para data; ISO.DATE_TIME; 
para data e hora e ISO.TIME para hora.

Com a simples inclusão destas anotações sobre os atributos da classe Funcionario, o 
processo de conversão estará ativado e o Spring MVC vai converter os valores 
enviados pelo formulário.


Formatando dados na página

Algumas vezes você pode querer formatar os valores que serão exibidos na página. 
O Thymeleaf fornece alguns recursos para isso. Um exemplo interessante que pode ser 
citado é o de formatação de valores monetários. O Thymeleaf exibe estes valores no 
formato americano (4050.60 ou 4,050.60), mas você pode alterar este comportamento 
usando uma simples expressão como está: ${‌{valor}}

Ao fazer uso dessa expressão o valor monetário informado vai ser automaticamente exibido 
na página com o formato local onde a aplicação está instalada. Se ela estiver rodando no 
Brasil, o formato será o brasileiro (4.050,60), se estiver rodando na Alemanha o 
formato será o alemão.

Só que algumas vezes, uma aplicação feita para brasileiros pode estar rodando em uma 
nuvem ou servidor fora do Brasil e assim, o formato final da expressão seria o do local 
referente a nuvem ou ao servidor. Então, seria necessário definir um padrão Locale na 
aplicação, para que ele seja usado independentemente do local em que a aplicação 
está instalada.

Este Locale pode ser incluído como um bean na própria classe de inicialização do 
Spring Boot, como no exemplo a seguir:

    @SpringBootApplication  
    public class DemoMvcApplication {        
    public static void main(String[] args) {  
        SpringApplication.run(DemoMvcApplication.class, args);  
    }  
        
    @Bean  
    public LocaleResolver localeResolver(){  
        return new FixedLocaleResolver(new Locale("pt", "BR"));  
    }  


Veja que o método localeResolver retorna um Locale configurado com o padrão pt_br 
o qual vai indicar o formato final dos valores monetários após a formatação.

O uso da declaração do Locale em Pt-Br também evita erros durante a conversão 
de dados. Por exemplo, se a mascara do componente de salário na página for no 
formato monetário do Brasil, mas o seu sistema operacional não está no idioma 
Português, a conversão irá gerar um erro devido o formato da mascara. 
Para evitar o erro, a mascara deve estar no formato monetário padrão do 
idioma do sistema operacional. Se o sistema operacional for o Windows em 
Inglês a mascara deve estar no formato americano, se estiver no formato 
brasileiro um erro será lançado.

Isso porque, o Spring Boot usa o Locale conforme o idioma do Sistema Operacional. 
Para usar a mascara no formato monetário brasileiro é necessário então, 
configurar o Locale neste formato, como mostrado no código acima. Isso 
também é útil para componentes de datas que estejam apresentando a data 
no formato americano. Ao configurar o Locale para Pt-br a data será 
exibida no padrão brasileiro.

Podemos também concatenar valores monetários que são exibidos na página com o 
tipo de moeda que este valor representa. Para isso, declaramos no componente 
th:text um par de pipes com uma string, contento o tipo de moeda mais 
a expressão de formatação:

    <p th:text="|R$ ${‌{valor}}|"/>

    ou

    <td th:text="${#numbers.formatCurrency(f.salario)}">0,00</td>

O resultado seria: R$ 4.050,60

Para as datas o padrão de saída do Thymeleaf também é o americano (2017/11/20), 
sendo assim, para exibir na página uma data com o formato brasileiro (20/11/2017) 
será necessário trabalhar com uma formatação.

Na classe Funcionario existem dois campos do tipo java.time.LocalDate. 
Este tipo de dado utiliza a expressão utilitária #temporals do Thymeleaf. 

Veja no exemplo a seguir:

<p th:text="${#temporals.format(f.dataEntrada, 'dd/MM/yyyy')}" />

A expressão é incluída como valor da expressão ${} e fornece o método format() 
para o processo de formatação. O método em questão recebe dois parâmetros. 
O primeiro é o valor da data e o segundo é o formato ao qual a 
expressão #temporals deve formata-lo.

Ressaltando que o #temporals só trabalha com objetos de datas derivados do 
pacote java.time. Tipos como java.util.Date ou java.util.Calendar podem ser 
formatados com a expressão ${‌{}}, onde o Locale será levado em consideração 
para a formatação final.

Editando funcionários

Algo que devemos dar atenção no formulário de funcionários é a parte 
referente ao endereço. Como temos um relacionamento 1:1 no banco de dados, 
entre funcionários e endereços, e estamos usando o mesmo formulário para 
salvar ambos os dados, no processo de atualização é importante enviar 
de volta ao controller não só o identificador do funcionário que está 
sendo alterado como também o identificador do endereço.

Caso o o identificador do endereço não seja enviado para o controller, 
o Hibernate não vai identificar este endereço na base de dados e então 
vai concluir que é um novo endereço e assim, o insere novamente. 
Esse processo vai gerar uma nova linha na tabela de endereços.

Na Aula 52, onde trabalhos com a operação de update de funcionários, 
incluímos a seguinte instrução para enviar o identificador do funcionário 
ao controller após submeter o formulário:

<input type="hidden" id="id" th:field="*{id}"/>

O mesmo processo deve ser realizado para também enviar o identificador 
do endereço:

    <input type="hidden" id="endereco.id" th:field="*{endereco.id}"/>

Dessa forma, quando houver uma operação de update, sendo o endereço 
editado ou não, garantimos que não será adicionada uma nova linha na 
tabela de endereços. Caso essa instrução não seja incluída, a 
cada submissão do formulário em uma operação de update, teremos 
um novo endereço salvo no banco.

Sendo assim, não deixe de incluir tal instrução na página 
templates/funcionario/cadastro.html.

    <form th:action="${funcionario.id == null} ? @{/funcionarios/salvar} : @{/funcionarios/editar}" 
        th:object="${funcionario}" method="POST">
            <!-- código omitido -->
        <input type="hidden" id="id" th:field="*{id}"/>
        <input type="hidden" id="endereco.id" th:field="*{endereco.id}"/>
        <button type="submit" class="btn btn-primary btn-sm">Salvar</button>
    </form>

Saiba mais sobre o Thymeleaf:

Data Conversion / Formatting - 
https://www.thymeleaf.org/doc/tutorials/3.0/usingthymeleaf.html#data-conversion-formatting

Literal substitutions - 
https://www.thymeleaf.org/doc/tutorials/3.0/usingthymeleaf.html#literal-substitutions

Module for Java 8 Time API compatibility - 
https://github.com/thymeleaf/thymeleaf-extras-java8time




Aulas 57 a 62 - Validação no Back end
-------------------------------------

A validação back-end é a validação de dados no lado servidor da aplicação. Esse é 
considerado o meio mais seguro de validação, já que, diferente de validação front-end, 
baseada em JavaScript, pode ser burlada.

No Java existe uma especificação para validação back-end a qual tem o nome de Bean 
Validation. Esse tipo de validação é baseado em anotação incluídas nas classes de 
entidades. Os atributos dessas classes são marcados com anotações do tipo @NotNull, 
@NotBlank, @Size, entre outras. Para que Bean Validations trabalhe é necessário 
incluir uma biblioteca que represente a implementação dessa especificação, 
como exemplo, temos a Hibernate-Validator.

. Bean Validation

    Atualmente a Bean Validations está na versão 2.0 (JSR 380) a qual trouxe algumas novas 
    anotações de validação como: @Email, @Positive, @PositiveOrZero, @PastOrPresent, 
    entre outras que podem ser estudas no site Bean Validation mantido pela 
    RedHat - http://beanvalidation.org

    Quando usamos o Spring MVC a validação back-end pode ser facilmente integrada ao Bean 
    Validation. Para isso, comece anotando os atributos de suas classes de entidades, 
    como no exemplo a seguir:

    @Entity
    @Table(name = "CARGOS")
    public class Cargo extends AbstractEntity<Long> {
    
        @NotBlank(message = "O nome do cargo é obrigatório.")
        @Size(max = 60, message = "O nome do cargo deve conter no máximo 60 caracteres.")
        @Column(name = "nome", nullable = false, unique = true, length = 60)
        private String nome;
        
        @NotNull(message = "Selecione o departamento relativo ao cargo.")
        @ManyToOne
        @JoinColumn(name = "id_departamento_fk")
        private Departamento departamento;
        
        @OneToMany(mappedBy = "cargo")
        private List<Funcionario> funcionarios;
    }

    Veja que na classe Cargo os atributos nome e departamento foram marcados com as anotações da 
    Bean Validation, que estão disponíveis no pacote javax.validation.constraints.*. 
    Observando com atenção, se pode notar que essas anotações possuem alguns atributos como o 
    message, para a inclusão da mensagem que será exibida ao usuário, max e min de limitam 
    uma quantidade minima e máxima de caracteres permitidos para o atributo.

    All of the annotations used in the example are standard JSR annotations:

    @NotNull – validates that the annotated property value is not null
    @AssertTrue – validates that the annotated property value is true
    @Size – validates that the annotated property value has a size between the attributes 
            min and max; can be applied to String, Collection, Map, and array properties
    @Min – vValidates that the annotated property has a value no smaller than the value attribute
    @Max – validates that the annotated property has a value no larger than the value attribute
    @Email – validates that the annotated property is a valid email address

    Some annotations accept additional attributes, but the message attribute is common to all 
    of them. This is the message that will usually be rendered when the value of the respective 
    property fails validation.

    Some additional annotations that can be found in the JSR are:

    @NotEmpty – validates that the property is not null or empty; can be applied to String, 
                Collection, Map or Array values
    @NotBlank – can be applied only to text values and validated that the property is 
                not null or whitespace
    @Positive and @PositiveOrZero – apply to numeric values and validate that they 
                                    are strictly positive, or positive including 0
    @Negative and @NegativeOrZero – apply to numeric values and validate that they are 
                                    strictly negative, or negative including 0
    @Past and @PastOrPresent – validate that a date value is in the past or the past 
                                including the present; can be applied to date types 
                                including those added in Java 8
    @Future and @FutureOrPresent – validates that a date value is in the future, or 
                                    in the future including the present

    Diferentes anotações podem ter diferentes atributos, mas em todas elas teremos o atributo 
    message para a inclusão da mensagem. Essa mensagem pode ser incluída literalmente com 
    um valor string ou por chaves existentes em arquivos de propriedades. As mensagens possuem 
    também uma mensagem padrão caso nenhum seja inserida na anotação.

    Ao trabalhar com um arquivo de propriedades, estes arquivo deve ser nomeado como 
    ValidationMessages.properties e estar inserido no classpath do projeto. 
    Em um projeto Maven seria em src/main/resources.

    Neste arquivo podemos trabalhar de duas formas. Uma delas é criar um padrão de mensagem para 
    cada tipo de anotação. Por exemplo, se no arquivo for incluída a propriedade:

        javax.validation.constraints.NotBlank.message = um valor é requerido.

    O valor dessa propriedade será adicionada como mensagem em todas as anotações do tipo @NotBlank. 
    Isso porque, a instrução como chave da propriedade aponta para essa anotação, já que é 
    formada pelo nome do pacote, nome da anotação e nome do atributo de mensagem. Assim, seria 
    necessário adicionar nas anotações @NotBlank o atributo message.

    Ainda no arquivo de propriedades poderíamos criar mensagens especificas para cada atributo 
    anotado na classe de entidade. Seria como adicionar nessas anotações o atributo message 
    com a mensagem, porém, a mensagem estaria no arquivo de propriedades. Veja um exemplo:

        NotNull.funcionario.cargo = Selecione um cargo.

    Com a propriedade inserida no arquivo basta agora referencia-la na anotação da classe. 
    Para isso, no atributo message insira a expressão "{}" com a chave da propriedade 
    como valor da expressão:

        @NotNull(message = "{NotNull.funcionario.cargo}")
        private Cargo cargo;

    Agora que você já sabe incluir regras de validação via anotações, é necessário integrar 
    esse recurso ao Spring MVC. Esse passo é bastante simples. Nos métodos dos controllers, 
    que recebem a submissão dos formulários, inclua a anotação @Valid ao lado do argumento 
    que representa o objeto que está sendo enviado pelos formulário. Essa anotação é do 
    pacote javax.validation.

        @Controller
        @RequestMapping("/cargos")
        public class CargoController {
            
            @Autowired
            private CargoService cargoService;
        
            @PostMapping("/salvar")
            public String salvar(@Valid Cargo cargo, 
                                BindingResult result, 
                                RedirectAttributes attr) {
                
                if (result.hasErrors()) {
                    return "/cargo/cadastro";
                }
                
                cargoService.salvar(cargo);
                attr.addFlashAttribute("success", "Cargo inserido com sucesso.");
                return "redirect:/cargos/cadastrar";
            }
        }

    No código apresentado, da classe CargoController, veja que o método salvar() tem 
    como primeiro argumento  um objeto da classe Cargo. Ao lado esquerdo desse 
    argumento foi adicionada a anotação @Valid. Agora, toda vez que o formulário 
    de cargo for submetido ao método salvar() ele será validado pelas anotações 
    dos atributos da classe Cargo.

    Porém, caso algum campo do formulário não passe pela validação, será necessário 
    exibir uma mensagem na página informando isso. Para esse processo temos o objeto 
    BindingResult inserido como segundo argumento do método salvar(). Veja que no 
    corpo do método há um teste condicional sobre a variável result. Essa variável 
    fornece o método hasErros() que retorna um valor true caso algum campo do 
    formulário não tenha passado na validação. Quando isso acontecer, o processo 
    será um retorno de volta a página do formulário.

    De volta a página é necessário então exibir as mensagens referentes aos campos 
    que não passaram na validação. Este passo agora depende do Thymeleaf o qual 
    fornece a expressão utilitária #fields. Esta expressão tem o método 
    detailedErrors() que retorna uma lista contendo todas as mensagens referentes 
    aqueles campos que não passaram na validação. Agora então, basta imprimir 
    na página essas mensagens. Para isso, faça um foreach em detailedErrors() 
    e imprima no componente th:text a variável message:

        <div th:each="error : ${#fields.detailedErrors()}">
            <span th:text="${error.message}"></span>
        </div>

    Este processo é interessante para exibir as mensagens de validação em um único 
    bloco de mensagens. Mas caso queira exibi-las diretamente nos campos do 
    formulário se pode usar o componente th:erros, sem precisar manipular o 
    detailedErrors(), como mostra o exemplo a seguir:

        <form th:action="@{/funcionarios/salvar}" th:object="${funcionario}" method="POST">
            <div class="form-row">
                <div class="form-group col-md-6">
                    <label for="nome">Nome do Funcionário</label>
                    <input type="text" id="nome" th:field="*{nome}"/>
                </div>    
                <div class="invalid-feedback">
                    <span th:errors="*{nome}"></span>
                </div>
            </div> 
            <button type="submit">Salvar</button>
        </form>

. Spring Validator

    Outra forma de validação back-end é o Spring Validator. Esse recurso é nativo 
    do Spring e não tem vinculo com a especificação Bean Validation. Para fazer 
    uso desse recurso é necessário criar uma classe que implemente a interface 
    Validator do pacote org.springframework.validation.

    A interface exige que sejam implementados dois métodos o supports() e o 
    validate(). O primeiro tem como objetivo verificar que o objeto enviado 
    pelo formulário é do mesmo tipo esperado pela classe de validação. Para isso, 
    bastar incluir um teste simples de verificação como corpo do método:

        @Override
        public boolean supports(Class<?> clazz) {        
            return Funcionario.class.equals(clazz);
        }

    Já o método validate() é onde a lógica de validação dos campos serão realizadas. 
    O método tem dois argumentos, um do tipo Object que contém a variável 
    enviada pelo formulário e outro do tipo Errors. Este objeto Errors será usado 
    para lançar as mensagens de validação nos respectivos campos.

        @Override
        public void validate(Object object, Errors errors) {
                
            Funcionario f = (Funcionario) object;        
                
            if (f.getNome() == null) {
                errors.rejectValue("nome", "O nome é obrigatório");
            }        
        
        }

    Veja que no método validate() a partir da variável object foi criada uma variável 
    Funcionario por meio de um cast.  Agora é possível criar qualquer lógica de validação 
    sobre os campos de Funcionario.  No exemplo apresentado temos um teste para verificar 
    se o campo nome enviado pelo formulário está nulo. Caso esteja, usamos a variável 
    errors para criar a mensagem de validação e avisar ao controller que um error ocorreu. 
    Isso é feito pelo método rejectValue() o qual como primeiro parâmetro recebe o nome do 
    campo validado e como segundo parâmetro a mensagem de validação.

    Desta forma você pode criar qualquer tipo de teste ou lógica para validar qualquer 
    campo do formulário. O Spring Validator também fornece um método para verificar se o 
    campo do formulário está em branco ou se possui apenas espaços em branco.  
    Veja um exemplo:

        @Override
        public void validate(Object object, Errors errors) {
                
            Funcionario f = (Funcionario) object;        
                
            ValidationUtils
                .rejectIfEmptyOrWhitespace(errors, "nome", "Nome é obrigatório.");    
        
        }

    As mensagens do Spring Validator podem também ser armazenadas em um arquivo de 
    propriedades, mas este arquivo deve ser o messages.properties. E para carregar 
    as mensagens basta substituir a string com a mensagem no método rejectValue() e 
    rejectIfEmptyOrWhitespace() pela chave da propriedade.

        errors.rejectValue("nome", "NotNull.funcionario.nome");

    Para finalizar o processo com o Spring Validator é preciso dizer ao controller 
    que ele deve usar a classe que implementou a interface Validator como validador 
    do formulário. Para isso, insira no controller o método initBinder(), como 
    no exemplo a seguir:

        @Controller
        @RequestMapping("/funcionarios")
        public class FuncionarioController {        
            @Autowired
            private FuncionarioService funcionarioService;
            
            @InitBinder
            public void initBinder(WebDataBinder binder) {
                binder.addValidators(new FuncionarioValidator());
            }
        
            @PostMapping("/salvar")
            public String salvar(@Valid Funcionario funcionario, BindingResult result, RedirectAttributes attr) {
                
                if (result.hasErrors()) {
                    return "/funcionario/cadastro";
                }
                
                funcionarioService.salvar(funcionario);
                attr.addFlashAttribute("success", "Funcionário inserido com sucesso.");
                return "redirect:/funcionarios/cadastrar";
            }
        }

    Veja que o método em questão foi marcado com a anotação @InitBinder. Esta 
    anotação vai instruir o Spring a executar este método como o primeiro da 
    classe. Assim, a classe FuncionarioValidator vai ser executada antes da 
    requisição chegar ao método salvar().  Quando então a requisição chegar ao 
    salvar() o Spring Validator já terá validado o formulário e em caso de 
    algum campo não ter passado na validação o teste condicional do 
    hasErrors() retornará true.



Aulas 63 e 64 - Mensagens via messages.properties
-------------------------------------------------


. Nomeando os componentes do HTML

    Um método bastante recomendado para incluir a descrição em componentes HTML como 
    botões, colunas de tabelas, menos, entre outros, é por meio de um arquivo de 
    propriedades. Desta forma, as descrições dos componentes ficam localizadas em 
    um único ponto, facilitando assim a manutenção das páginas.

    Mas é importante que as chaves das propriedades que contém as descrições dos 
    componentes, sejam nomeadas de forma organizada, de modo que, o nome de 
    cada propriedade remeta diretamente para o componentes referente.

    Por exemplo, para nomear um componente da pagina funcionario.html, use o nome 
    da página como parte da chave da propriedade, como também, usar o nome do 
    componente que será nomeado irá ajudar bastante:

    tabela.funcionario.col.nome = Nome

    ou

    funcionario.tabela.coluna.nome = Nome

    Já no componente HTML da página será preciso incluir uma expressão do tipo
    #{} com a chave da propriedade referente e essa expressão deverá ser incluída 
    em um componente th:text do Thymeleaf:

        <table>
            <thead>
                <tr>
                    <th th:text="#{tabela.funcionario.col.nome}"></th>
                    <th th:text="#{tabela.funcionario.col.salthario}"></th>    
                    <th th:text="#{tabela.funcionario.col.departamento}"></>        
                </tr>
            </thead>
            ...
        </table>

    Sobre arquivos de propriedades é importante destacar que eles não trabalham 
    muito bem com caracteres especiais, entre eles, acentos e cê-cedilhas. Esses 
    caracteres quando incluídos no arquivo de propriedades podem ser substituídos 
    na página HTML por outros caracteres não correspondentes. Por exemplo, 
    a palavra Funcionário poderia aparecer na página como Funcionário.

    Isso ocorre porque não podemos definir uma declarativa com a instrução do 
    charset/encoding como fazemos em arquivos .html ou .xml. Por esse motivo 
    o charset será aquele referente ao sistema operacional. Para quem usa 
    Windows o charset/encoding é o windows-1252 o que pode gerar os 
    problemas citados quando incluído em uma página .html com charset UTF-8.

    Existem duas forma de se resolver essa questão, uma delas é alterar na 
    IDE o charset/encoding que ela vai salvar o arquivo de propriedades, o ideal 
    é setá-lo para UTF-8. Porém, mesmo assim, fica difícil saber quando um 
    arquivo de propriedades foi criado com um ou com outro tipo charset/encoding. 
    Então, você pode acabar abrindo um projeto com o arquivo em UTF-8, alterar 
    algo nesse arquivo e salva-lo como windows-1252 se não configurou sua IDE 
    para UTF-8 e assim, voltará a ter problemas.

    Para evitar essa confusão, outro forma, talvez a mais indicada para resolver 
    este problema, é substituir o caractere especial por um caractere Unicode. 
    Na web existem diversos sites com tabelas Unicodes, essas tabelas têm o 
    código unicode referente ao caractere especial. Um desses sites é 
    o https://unicode-table.com/pt/.

    Para incluir o código unicode no arquivo de propriedades é necessário 
    inicia-lo pelos caracteres \u, como apresentado no exemplo a seguir:

    tabela.funcionario.col.salario = Sal\u00E1rio
    tabela.funcionario.col.endereço = Endere\u00E7o

    Veja que nas propriedades apresentadas o caractere á de Salário, foi 
    substituído pelo codificação \u00E1. Já o ç de Endereço foi alterado 
    por \u00E7.



Aulas 65 a 67 - Página de Erro
------------------------------

. Personalizando a página de erro

    O Spring Boot tem uma página padrão para exibição de erros que ocorrem durante a execução de 
    uma aplicação. A página é similar a exibida na figura 1:

    Está página possuir algumas poucas informações distribuídas em cinco variáveis que são:

    timestamp - contém a data e hora da geração do erro
    status - contém o código do Status do erro (400, 404, 500, 503, …)
    error - vai conter a descrição do status de erro (Not Found, Internal Server Error, …)
    message - contém uma mensagem sobre o erro
    path - cai conter o path da URL ou URI que gerou o erro

    Conhecendo estas variáveis é possível criar uma página de erro personalizada, nomeada 
    como error.html e adicionado no diretório templates. É importante o nome do arquivo 
    e seu local, já que estas serão as referencias procuradas pelo Spring Boot para 
    substituir sua página de erro padrão. Veja a seguir um pseudo-código apresentado 
    esta operação:

        <code><body class="text-center">
            <div>
                <h1 class="h3 mb-3 font-weight-normal">
                    <i class="oi oi-warning"></i> 
                    <span th:text="${status}"></span>
                </h1>
                
                <h2 th:text="${error}"></h2>
                
                <div>
                    <span th:text="${message}"></span><br/><br/>
                </div>
            </div>
        </body>
        </code>

    Observe que nas tags span de h1, h2 e div temos o componente th:text do Thymeleaf e 
    como valor este componente recebe as variáveis status, error e message. Assim temos 
    um exemplo de como incluir as variáveis de mensagens da operação de erro em uma página 
    que vai substituir a página padrão do Spring Boot. Esta página poderia ser como a 
    da figura 2:

    Entretanto, veja que as mensagens apresentadas tanto na página padrão quando na página 
    personalizada, estão em Inglês e com um descrição do erro muito técnica. Sendo assim, 
    poderíamos alterar as mensagens de erro para mensagens mais claras e em Português. 
    Para isso, é necessário criar uma classe que implemente a interface ErrorViewResolver 
    do pacote org.springframework.boot.autoconfigure.web.servlet.error 
    (na versão Spring Boot 2.0).

    Esta interface exige a implementação do método resolveErrorView() o qual tem a 
    seguinte assinatura:

    <code>

        public ModelAndView resolveErrorView(HttpServletRequest request,
                                            HttpStatus status,
                                            Map<String, Object> map); 

    </code>

    O método possui três argumentos que são:

    HttpRequest - este objeto vai conter as informações atuais do request que gerou a página de erro
    HttpStatus - aqui você terá acesso ao código e a descrição do status do erro.
    Map<String, Object> - contém aquelas cinco variáveis com as informações referentes ao erro.
    Veja agora como implementar a interface ErrorViewResolver em uma classe nomeada como MyErrorView:

        <code>
            @Component
            public class MyErrorView implements ErrorViewResolver {
            
                @Override
                public ModelAndView resolveErrorView(HttpServletRequest request, 
                                                        HttpStatus status, 
                                                        Map<String, Object> map) {
                    
                    ModelAndView model = new ModelAndView("error");
                    model.addObject("status", status.value());
                    switch (status.value()) {
                            case 404:
                                model.addObject("error", "Página não encontrada.");
                                model.addObject("message", 
                                                "A url para a página '" + map.get("path") + "' não existe.");
                                break;
                            case 500:
                                model.addObject("error", "Ocorreu um erro interno no servidor.");
                                model.addObject("message", "Ocorreu um erro inexperado, tente mais tarde.");
                                break;
                            default:
                                model.addObject("error", map.get("error"));
                                model.addObject("message", map.get("message"));
                                break;
                    }        
                    return model;
                }    
            }
        </code>

    Usamos aqui um objeto ModelAndView para substituir as mensagens padrões de erro do Spring 
    Boot. Porém, para determinar qual mensagem deve ser apresentada na página de erro, 
    usamos o código do status de erro, obtido a partir do argumento HttpStatus. Assim é 
    possível saber se o erro gerado é um 404, 500, ou qualquer outro e adicionar ao 
    ModelAndView uma mensagem especifica e em Português.


Aulas 68 a 69 - Criação do jar da aplicação
-------------------------------------------

1. Acesse Windows -> Preferences -> Java -> Installed JREs -> Edit

    Escolha a pasta onde encontra-se a instação do JRE

2. Clique direito no nó principal do projeto e escolha a opção:

    Run As... -> maven build

3. Na tela "Edit Configuration", coloque nos campos:

    Name:   demo-mvc - mvn package 
    Goals:  package -e

4. Clique no botão;

    Apply -> Run

5. Acesse as classes abaixo e retire a barra inicial de endereços URL, com excessão
    das que são chamadas através de redirect:/...

    MyErrorView ( deixar o modelAndView assim: ModelAndView model = new ModelAndView("error"); )
    [all]Controller ( deixar os retornos dos metodos sem a barra inicial: return "cargo/cadastro"; )