Anotações do curso Spring Boot, JPA e Hibernate — Parte 1
Published: 2020-10-15 23:45:11

__Introdução__

Há algumas semanas, assisti um vídeo excelente do Felipe Deschamps (que pode ser visto aqui) e decidi começar uma nova série de artigos compartilhando minhas anotações pessoais de inúmeros cursos de programação que fiz nos últimos dois anos relacionados à programação.

Para estrear, vou trazer uma anotação extensa de um curso que fiz recentemente do universo do Spring. Neste artigo, acabei misturando um pouco os meus métodos de escrita de artigos e de estudo, mas acredito que dê para entender o conteúdo em si. Caso eu tenha cometido alguns erros técnicos ou de semântica, fiquem à vontade para deixar seu feedback por aqui, vou ficar muito feliz!

Quero ressaltar que este artigo não é um tutorial de como fazer alguma coisa em Spring e também não é um curso completo, apenas estou compartilhando estes registros para ajudar quem também está estudando esta stack, e que pode ter tido as mesmas dúvidas que eu tive. Utilize-o apenas como um material complementar de consulta para seus estudos.

Em resumo, o Spring é um framework Java que foi criado com o objetivo de facilitar o desenvolvimento de aplicações, utilizando os conceitos de Inversão de Controle e Injeção de Dependências. O Spring Boot é uma ferramenta que visa facilitar o processo e configuração e publicação de aplicações que usam o Spring, de maneira pé-configurado.

__Configurações__

Para começar um projeto, adicione todas as dependências e importações necessárias para a aplicação no arquivo pom.xml. No arquivo application.properties, é necessário adicionar as configurações do banco de dados (utilizei o banco de dados Oracle), vai ficar mais menos assim:

spring.datasource.url= jdbc:oracle:thin:@localhost:1521:xe
spring.datasource.username=System
spring.datasource.password= suasenha
spring.datasource.driver-class-name=oracle.jdbc.driver.OracleDriver
spring.batch.job.enabled=false
spring.jpa.hibernate.ddl-auto = update
spring.jpa.show-sql=true

O campo username e senha são os dados de acesso do banco, em ddl-auto se colocar como “update” o banco será atualizado após cada salvamento de arquivo e a url é a referência de onde está o banco (pode estar em um site externo), com o “create”, o banco é criado uma vez só, e com “create-drop”, nós zeramos todos os dados do banco e recriamos ele.

OBS: Boilerplate code se refere a seções de códigos que devem ser incluídas em muitos lugares, com pouca ou nenhuma alteração. Vamos utilizar as anotações (annotations) no Spring para reduzir a geração de linhas de códigos desnecessárias.

__Padrão MVC (Model-View-Controller)__
MVC é um padrão de arquitetura de software que separa sua aplicação em 3 camadas. A camada de interação do usuário (View), a camada de manipulação dos dados (Model) e a camada de controle (Controller). O View faz apenas a exibição dos dados (html/xml), o Model é o responsável pela leitura e escrita de dados (além de suas validações). E o Controller é o responsável por receber todas as requisições do usuário e, os seus métodos, chamados de actions, são responsáveis por uma página, controlando qual model usar e qual view será mostrado ao usuário.
· A sequência de criação das classes e pacotes do projeto são: Model (Entity), Repository, Service, Controller.
· O pacote Model é onde ficará os modelos da aplicação.
· O pacote Repository é onde fica a classe que fará transações com o banco de dados, ou seja, é um Design Pattern onde os dados são obtidos do banco de dados e ocorre também a regra de negócio. Este retorna objetos de domínio que seriam as Entidades (classes anotadas com @Entity). Ele é a subcamada responsável por persistência de dados (recuperar, atualizar, inserir, apagar).
· Service é outro Design Pattern onde há somente a regra de negócio e que não tem acesso direto ao banco de dados. É a subcamada responsável pela regra de negócio (valida dados, executa regra de negócio, usa a repository e a entity para ter acesso e persistir dados).
· Já o Controller é utilizado para lidar com a ligação da View com as outras partes do sistema que são a regra de negócio e banco de dados.
· DAO é outro Design Pattern onde somente há a comunicação com o banco de dados sem regra de negócio. É a subcamada responsável pela regra de negócio (valida dados, executa regra de negócio, usa a repository e a entity para ter acesso e persitir dados).
JPA (Java Persistance API)
· No repository, crie uma interface que estende JpaRepository<Post, Long>. O primeiro parâmetro (Post) é a classe que vamos querer que se comunique com o banco de dados. O segundo parâmetro (Long), é a classe Wrapper do ID da classe/tabela, que o banco poder fará a referência.
· O JpaRepository possui alguns métodos próprios para realizar operações de CRUD e buscas por parâmetros com as nossas clases do Model, que são muito utilizados no dia a dia. Como por exemplo:
o findAll() — retorna uma lista com todos os elementos da classe.
o findAllById() — busca um elemento através do seu id e o retorna.
o save — salva um elemento na tabela (cria um novo elemento).
o saveAll() — salva todos os elementos na tabela (para casos de array ou objetos compostos).
o get() — pegar os elementos para realizar operações, podendo ser combinado com o byId ou o All.
· No service, vamos criar todos os métodos que farão as operações de CRUD no banco de dados (busca todos, busca por id, salvar dados, atualizar dados, excluir, busca avançada, etc).
· O controller faz o meio de campo entre o back-end e o banco de dados, ele terá todos os métodos com os verbos HTTP de comunicação e chamará os métodos de operações, que criamos no service.
Anotações (Annotations)
As anotações foram introduzidas no Java 5 e é um recurso utilizado para anotar métodos, campos e classes, de forma que essas marcações possam ser tratadas pelo compilador, ferramentas de desenvolvimento e bibliotecas. Uma anotação muito utilizada no Java é o @Override, que sobrescreve métodos.
· As annotation são quase sempre colocadas em cima do atributo/classe/métodos que você deseja referenciar.
· A annotation @Entity significa que uma classe é uma entidade (ou seja, ela é uma tabela no banco de dados). É a nossa classe principal, onde ficará os atributos dos objetos, construtores, getters e setters. Como é uma tabela, podemos declarar o nome dela usando @Table(name = ”TB_EXEMPLO”)
· Para declarar o id único da classe, use a annotation @Id. Para gerar o id automaticamente, usa-se o @GeneratedValue(strategy = GenerationType.AUTO) e, embaixo, coloque @SequenceGenerator (name = “useraluno_sequence”, sequenceName = “user_seq_id”, allocationSize = 1), se utilizar banco de dados Oracle (pois possui tecnologia sequence). Caso esteja utilizando o MySQL, você terá que definir o valor inicial direto no banco de dados.
· Colocando a annotation @NotBlank em cima de um atributo, você indica que este campo não poderá ser nulo (campo obrigatório).
· O annotation @Lob permite receber textos muito longos no atributo.
· Para formatar a data, use a annotation @JsonFormat (shape=JsonFormat.Shape.STRING, pattern=”dd-MM-yyyy”)
· A annotation @Autowired realiza uma injeção de dependências (para poder usar as instâncias do repository)
· Marcar uma classe com @Service, indica que ela será um bean gerenciado pelo Spring MVC (é um serviço).
· O @Component é um dos estereótipos que define para o Spring que a classe será um bean gerenciado por ele. Existe outros tipos estereótipos, como @Service, @Controller, @Repositoy que podem ser utilizados também, de acordo com o objetivo e função da classe. A anotação @Component é mais genérica.
· A anotação @PostConstructor ela é utilizada sempre que for preciso executar determinado método ao inicializar a aplicação, independente da classe ou entidade.
· A anotação @Controller mostra que a classe controller será um bean gerenciada pelo Spring.
· A anotação @RequestMapping determina qual método HTTP será utilizado e qual será sua URL. Por exemplo, em @RequestMapping(value = “/posts”, method = RequestMethod.GET) nós temos a URL “/posts” e o método HTTP será o GET (vai buscar informações do banco de dados e retorna-las). Algumas anotações possuem parâmetros para manipular um dado por vez (by Id) ou todos ao mesmo tempo (All). A partir do Spring Framework 4.3, surgiram novas anotações que expressam de forma mais clara o que cada método está fazendo, são eles:
- @GetMapping utiliza o verbo GET, buscando informações do banco.
- @PostMapping utiliza o verbo POST, para inserir novos dados no banco.
- @PatchMapping utiliza o verbo PATCH, fazendo modificações em campos do banco.
- @DeleteMapping utiliza o verbo DELETE, excluindo dados do banco;
· O @PathVariable é utilizado quando o valor da variável é passada diretamente na URL, mas não como um parâmetro que você passa após o sinal de interrogação (?) mas sim quando o valor faz parte da url.
· O @RequestParam é utilizado quando temos vários parâmetros passados por uma url (como nome e email).
· O @RequestBody é usada para requisitar um corpo de argumentos em métodos HTTP.
· O @Value indica um valor padrão inicial para um campo (permite configurar uma label).
· O @Data (importado do Lombok) serve para gerar automaticamente os getters, settters, toString (não cria o construtor). Basta colocá-lo em cima da classe model para ativá-lo. Também é possível colocar o @Getter e o @Setter em cada um dos atributos (caso não queira gerar todos eles com o @Data).
· O @AllArgsConstructor cria um construtor com todos os atributos e o @NoArgsConstructor cria um construtor sem atributos.
· O @OneToMany(mappedBy = “categoria_id”) é inserido em cima de um atributo, e informa que o registro de uma entidade está relacionado com vários registros de outra entidade. O mappedBy fica dentro do @OneToMany e é usado no lado fraco do relacionamento e faz com que o relacionamento seja bidirecional.
· O @ManyToOne é inserido em cima de um atributo, informa um tipo de relacionamento muitos para um (vários registros de uma entidade estão relacionados com um registro de outra entidade).
· A anotação @JoinColumn indica que a classe/atributo na qual você está utilizando-a é a dona ou o lado forte do relacionamento. Isso apenas adiciona uma coluna estrangeira ao lado forte.
· O @JoinTable é utilizado para criar uma referência entre duas tabelas. Por exemplo, vamos supor que nós temos as tabelas de Aluno e Faculdade, e que cada faculdade terá vários alunos, mas o aluno vai estudar em apenas uma faculdade. Nesse caso, vamos precisar de uma terceira tabela para fazer o mapeamento dos alunos para a faculdade. Esta tabela intermediária (vamos chamar de Faculdade_Aluno) vai possuir duas chaves estrangeiras (uma de Aluno e outra de Faculdade) para ligar as três tabelas. Para fazermos o mapeamento desta situação, utilizamos a anotação @JoinTable no Spring. Segue um exemplo:

@JoinTable(name=”faculdade_aluno”,
joinColumns = {@JoinColumn(name = “faculdade_id”,
referencedColumnName = “id”)},
inverseJoinColumns = {@JoinColumn(name = “aluno_id”,
referencedColumnName = id”)})

A parte 2 das anotações já está no ar!