S02L08 - Usar o usuário do banco de dados usando JPA para JWT

html

Aproveitando o JPA para Gerenciamento de Usuários no Spring Boot com Autenticação JWT
Índice

Introdução
Configuração do Projeto Spring Boot

Adicionando Dependências
Configurando Propriedades da Aplicação


Criando o Modelo de Dados

Entidade Account
Repositório Account


Implementando a Camada de Serviço

Serviço Account


Inicialização de Dados Seed
Configuração de Segurança

Bean Password Encoder


Configuração do Controller

Controller Account
Controller Auth


Executando a Aplicação
Conclusão


Introdução
Em aplicações web modernas, gerenciar a autenticação e autorização de usuários é fundamental para garantir segurança e experiências personalizadas para o usuário. Este eBook explora o aproveitamento do Java Persistence API (JPA) em uma aplicação Spring Boot para lidar com detalhes de usuários armazenados diretamente em um banco de dados, integrados com JSON Web Token (JWT) para autenticação segura.
Pontos Principais:

Transição de detalhes de usuários em memória para gerenciamento de usuários baseado em banco de dados.
Configuração do Spring Boot com JPA e H2 Database.
Implementação de codificação de senha segura.
Configuração de autenticação baseada em JWT.

Prós e Contras



Prós
Contras




Segurança aprimorada ao armazenar dados de usuários em um banco de dados
Complexidade adicional na configuração e setup


Escalabilidade para lidar com um grande número de usuários
Requer entendimento de JPA e Spring Security


Flexibilidade no gerenciamento de funções e permissões de usuários
Potencial sobrecarga de desempenho com interações de banco de dados



Quando e Onde Usar
Esta configuração é ideal para aplicações que requerem gerenciamento robusto de usuários, escalabilidade e recursos de segurança aprimorados, como aplicações empresariais, plataformas de e-commerce e serviços de mídia social.

Configuração do Projeto Spring Boot
Adicionando Dependências
Para começar, iremos inicializar um projeto Spring Boot usando o Spring Initializer com as seguintes dependências:

Maven: Como a ferramenta de automação de build.
Spring Data JPA: Para capacidades de ORM.
H2 Database: Um banco de dados em memória para desenvolvimento e testes.
Validation: Para impor restrições na entrada de usuários.

Passos:

Navegue até Spring Initializer.
Selecione Maven como o tipo de projeto.
Adicione as seguintes dependências:

Spring Data JPA
H2 Database
Spring Boot Starter Validation


Clique em Generate para baixar o arquivo do projeto.
Extraia o arquivo e abra o projeto na sua IDE preferida.

Snippet do pom.xml:




		
		
			
			
Java
			
			
<dependencies>
    <!-- Spring Data JPA -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    
    <!-- H2 Database -->
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>
    
    <!-- Validation -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-validation</artifactId>
    </dependency>
    
    <!-- Outras dependências -->
    <!-- ... -->
</dependencies>

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
				
						 
<dependencies>
    <!-- Spring Data JPA -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    
    <!-- H2 Database -->
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>
    
    <!-- Validation -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-validation</artifactId>
    </dependency>
    
    <!-- Outras dependências -->
    <!-- ... -->
</dependencies>
 
					
				
			
		



Configurando Propriedades da Aplicação
Em seguida, configure as propriedades da aplicação para estabelecer a conexão com o banco de dados e outras configurações essenciais.
src/main/resources/application.properties:




		
		
			
			
Java
			
			
# Configuração do Servidor
server.port=8080

# Configuração do Banco de Dados H2
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect

# Configuração do Hibernate
spring.jpa.hibernate.ddl-auto=create-drop

# Habilitar Console H2
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
				
						 
# Configuração do Servidor
server.port=8080
 
# Configuração do Banco de Dados H2
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
 
# Configuração do Hibernate
spring.jpa.hibernate.ddl-auto=create-drop
 
# Habilitar Console H2
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console
 
					
				
			
		


Configurações Principais Explicadas:



Propriedade
Descrição




server.port
Define a porta na qual a aplicação roda. O padrão é 8080.


spring.datasource.url
URL JDBC para conexão com o banco de dados H2.


spring.jpa.hibernate.ddl-auto
Gerencia a geração do esquema do banco de dados. create-drop criará o esquema na inicialização e o descartará no desligamento.


spring.h2.console.enabled
Habilita o console do banco de dados H2 para interações diretas com o banco de dados.


spring.h2.console.path
Especifica o caminho URL para acessar o console H2.




Criando o Modelo de Dados
Entidade Account
A entidade Account representa os detalhes do usuário armazenados no banco de dados. Inclui campos como id, email, password e role.
src/main/java/org/studyeasy/SpringRestdemo/model/Account.java:




		
		
			
			
Java
			
			
package org.studyeasy.SpringRestdemo.model;

import javax.persistence.*;

@Entity
public class Account {

    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE)
    private Long id;

    @Column(unique = true, nullable = false)
    private String email;

    @Column(nullable = false)
    private String password;

    private String role;

    // Construtores
    public Account() {}

    public Account(String email, String password, String role) {
        this.email = email;
        this.password = password;
        this.role = role;
    }

    // Getters e Setters
    // Método toString
    // ...
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
				
						 
package org.studyeasy.SpringRestdemo.model;
 
import javax.persistence.*;
 
@Entity
public class Account {
 
    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE)
    private Long id;
 
    @Column(unique = true, nullable = false)
    private String email;
 
    @Column(nullable = false)
    private String password;
 
    private String role;
 
    // Construtores
    public Account() {}
 
    public Account(String email, String password, String role) {
        this.email = email;
        this.password = password;
        this.role = role;
    }
 
    // Getters e Setters
    // Método toString
    // ...
}
 
					
				
			
		


Anotações Principais:

@Entity: Marca a classe como uma entidade JPA.
@Id: Especifica a chave primária.
@GeneratedValue: Define a estratégia para geração da chave primária.
@Column: Configurações específicas da coluna, como unicidade e possibilidade de nulos.

Repositório Account
A interface AccountRepository estende JpaRepository para fornecer operações CRUD para a entidade Account.
src/main/java/org/studyeasy/SpringRestdemo/repository/AccountRepository.java:




		
		
			
			
Java
			
			
package org.studyeasy.SpringRestdemo.repository;

import org.studyeasy.SpringRestdemo.model.Account;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.Optional;

public interface AccountRepository extends JpaRepository<Account, Long> {
    Optional<Account> findByEmail(String email);
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
				
						 
package org.studyeasy.SpringRestdemo.repository;
 
import org.studyeasy.SpringRestdemo.model.Account;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.Optional;
 
public interface AccountRepository extends JpaRepository<Account, Long> {
    Optional<Account> findByEmail(String email);
}
 
					
				
			
		


Métodos Principais:

findByEmail(String email): Método de consulta personalizado para recuperar uma conta por email.


Implementando a Camada de Serviço
Serviço Account
A camada de serviço contém a lógica de negócio e interage com o repositório para gerenciar as entidades Account.
src/main/java/org/studyeasy/SpringRestdemo/service/AccountService.java:




		
		
			
			
Java
			
			
package org.studyeasy.SpringRestdemo.service;

import org.studyeasy.SpringRestdemo.model.Account;
import org.studyeasy.SpringRestdemo.repository.AccountRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;

@Service
public class AccountService {

    @Autowired
    private AccountRepository accountRepository;

    @Autowired
    private PasswordEncoder passwordEncoder;

    public Account save(Account account) {
        account.setPassword(passwordEncoder.encode(account.getPassword()));
        return accountRepository.save(account);
    }
    
    // Métodos adicionais do serviço
    // ...
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
				
						 
package org.studyeasy.SpringRestdemo.service;
 
import org.studyeasy.SpringRestdemo.model.Account;
import org.studyeasy.SpringRestdemo.repository.AccountRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
 
@Service
public class AccountService {
 
    @Autowired
    private AccountRepository accountRepository;
 
    @Autowired
    private PasswordEncoder passwordEncoder;
 
    public Account save(Account account) {
        account.setPassword(passwordEncoder.encode(account.getPassword()));
        return accountRepository.save(account);
    }
    
    // Métodos adicionais do serviço
    // ...
}
 
					
				
			
		


Funcionalidade:

save(Account account): Codifica a senha do usuário antes de salvar a conta no banco de dados, garantindo a segurança da senha.


Inicialização de Dados Seed
Para popular o banco de dados com dados iniciais de usuários, o componente SeedData implementa CommandLineRunner.
src/main/java/org/studyeasy/SpringRestdemo/config/SeedData.java:




		
		
			
			
Java
			
			
package org.studyeasy.SpringRestdemo.config;

import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import org.studyeasy.SpringRestdemo.model.Account;
import org.studyeasy.SpringRestdemo.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;

@Component
public class SeedData implements CommandLineRunner {

    @Autowired
    private AccountService accountService;

    @Override
    public void run(String... args) throws Exception {
        Account account1 = new Account("user1@user.com", "password1", "ROLE_USER");
        Account account2 = new Account("user2@user.com", "password2", "ROLE_USER");
        accountService.save(account1);
        accountService.save(account2);
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
				
						 
package org.studyeasy.SpringRestdemo.config;
 
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import org.studyeasy.SpringRestdemo.model.Account;
import org.studyeasy.SpringRestdemo.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
 
@Component
public class SeedData implements CommandLineRunner {
 
    @Autowired
    private AccountService accountService;
 
    @Override
    public void run(String... args) throws Exception {
        Account account1 = new Account("[email protected]", "password1", "ROLE_USER");
        Account account2 = new Account("[email protected]", "password2", "ROLE_USER");
        accountService.save(account1);
        accountService.save(account2);
    }
}
 
					
				
			
		


Explicação:

@Component: Marca a classe como um componente gerenciado pelo Spring.
CommandLineRunner: Executa o método run após a inicialização da aplicação para inserir dados seed.
Seed Accounts: Cria duas contas de usuário com senhas codificadas.


Configuração de Segurança
Bean Password Encoder
Para lidar com a codificação de senhas, defina um bean PasswordEncoder usando BCrypt.
src/main/java/org/studyeasy/SpringRestdemo/config/SecurityConfig.java:




		
		
			
			
Java
			
			
package org.studyeasy.SpringRestdemo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

@Configuration
public class SecurityConfig {

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
    
    // Configurações adicionais de segurança
    // ...
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
				
						 
package org.studyeasy.SpringRestdemo.config;
 
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
 
@Configuration
public class SecurityConfig {
 
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
    
    // Configurações adicionais de segurança
    // ...
}
 
					
				
			
		


Pontos Principais:

BCryptPasswordEncoder: Proporciona criptografia robusta para senhas.
@Bean: Registra o PasswordEncoder no contexto do Spring para injeção de dependência.


Configuração do Controller
Controller Account
Gerencia requisições HTTP relacionadas a usuários, como registro e recuperação.
src/main/java/org/studyeasy/SpringRestdemo/controller/AccountController.java:




		
		
			
			
Java
			
			
package org.studyeasy.SpringRestdemo.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.studyeasy.SpringRestdemo.model.Account;
import org.studyeasy.SpringRestdemo.service.AccountService;

@RestController
@RequestMapping("/api/accounts")
public class AccountController {

    @Autowired
    private AccountService accountService;

    @PostMapping("/register")
    public Account registerAccount(@RequestBody Account account) {
        return accountService.save(account);
    }

    // Endpoints adicionais
    // ...
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
				
						 
package org.studyeasy.SpringRestdemo.controller;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.studyeasy.SpringRestdemo.model.Account;
import org.studyeasy.SpringRestdemo.service.AccountService;
 
@RestController
@RequestMapping("/api/accounts")
public class AccountController {
 
    @Autowired
    private AccountService accountService;
 
    @PostMapping("/register")
    public Account registerAccount(@RequestBody Account account) {
        return accountService.save(account);
    }
 
    // Endpoints adicionais
    // ...
}
 
					
				
			
		


Endpoints:

POST /api/accounts/register: Registra uma nova conta de usuário salvando-a no banco de dados com uma senha codificada.

Controller Auth
Gerencia processos de autenticação, incluindo login e geração de token.
src/main/java/org/studyeasy/SpringRestdemo/controller/AuthController.java:




		
		
			
			
Java
			
			
package org.studyeasy.SpringRestdemo.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.studyeasy.SpringRestdemo.payload.auth.UserLogin;
import org.studyeasy.SpringRestdemo.payload.auth.Token;
import org.studyeasy.SpringRestdemo.service.TokenService;

@RestController
@RequestMapping("/api/auth")
public class AuthController {

    @Autowired
    private TokenService tokenService;

    @PostMapping("/login")
    public Token login(@RequestBody UserLogin userLogin) {
        // Lógica de autenticação
        // Geração de token
        return tokenService.generateToken(userLogin);
    }
    
    // Endpoints adicionais de autenticação
    // ...
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
				
						 
package org.studyeasy.SpringRestdemo.controller;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.studyeasy.SpringRestdemo.payload.auth.UserLogin;
import org.studyeasy.SpringRestdemo.payload.auth.Token;
import org.studyeasy.SpringRestdemo.service.TokenService;
 
@RestController
@RequestMapping("/api/auth")
public class AuthController {
 
    @Autowired
    private TokenService tokenService;
 
    @PostMapping("/login")
    public Token login(@RequestBody UserLogin userLogin) {
        // Lógica de autenticação
        // Geração de token
        return tokenService.generateToken(userLogin);
    }
    
    // Endpoints adicionais de autenticação
    // ...
}
 
					
				
			
		


Funcionalidade:

POST /api/auth/login: Autentica o usuário e retorna um token JWT após um login bem-sucedido.


Executando a Aplicação

Build do Projeto: Assegure-se de que todas as dependências estão resolvidas e o projeto é compilado com sucesso.

        



		
		
			
			
Java
			
			mvn clean install
			
				
					
				
					1
				
						mvn clean install
					
				
			
		


    
Executar a Aplicação: Inicie a aplicação Spring Boot.

        



		
		
			
			
Java
			
			mvn spring-boot:run
			
				
					
				
					1
				
						mvn spring-boot:run
					
				
			
		


    
Acessar o Console H2: Navegue até http://localhost:8080/h2-console para visualizar o banco de dados em memória. Utilize a URL JDBC jdbc:h2:mem:testdb com o usuário sa e sem senha.
Testar Endpoints: Use ferramentas como Postman para testar os endpoints da API para registro e autenticação de usuários.


Conclusão
Este eBook forneceu um guia abrangente para implementar um sistema robusto de gerenciamento de usuários em uma aplicação Spring Boot usando JPA e JWT para autenticação. Ao transitar de detalhes de usuários em memória para uma abordagem baseada em banco de dados, os desenvolvedores podem alcançar segurança aprimorada, escalabilidade e flexibilidade no gerenciamento de dados de usuários.
Pontos Principais:

Integração Spring Boot & JPA: Gerencie entidades de usuários de forma fluida com Spring Data JPA.
Segurança de Senha: Utilize BCrypt para codificar senhas, garantindo que sejam armazenadas de forma segura.
Autenticação JWT: Implemente autenticação baseada em token para sessões de usuários seguras e sem estado.
Inicialização de Dados Seed: Popule dados de usuários iniciais automaticamente durante a inicialização da aplicação.

SEO Keywords:
Spring Boot, JPA, Autenticação JWT, Gerenciamento de Usuários, H2 Database, Spring Security, Password Encoder, BCrypt, REST API, Spring Data JPA, Autenticação em Memória, Detalhes de Usuário Baseados em Banco de Dados, Spring Initializer, CommandLineRunner, Dados Seed, Autenticação Baseada em Token, Armazenamento Seguro de Senhas, Serviços RESTful, Spring Controller, Account Service, Account Repository
Este artigo foi gerado por IA.
Propriedade	Descrição
server.port	Define a porta na qual a aplicação roda. O padrão é 8080.
spring.datasource.url	URL JDBC para conexão com o banco de dados H2.
spring.jpa.hibernate.ddl-auto	Gerencia a geração do esquema do banco de dados. create-drop criará o esquema na inicialização e o descartará no desligamento.
spring.h2.console.enabled	Habilita o console do banco de dados H2 para interações diretas com o banco de dados.
spring.h2.console.path	Especifica o caminho URL para acessar o console H2.
Prós	Contras
Segurança aprimorada ao armazenar dados de usuários em um banco de dados	Complexidade adicional na configuração e setup
Escalabilidade para lidar com um grande número de usuários	Requer entendimento de JPA e Spring Security
Flexibilidade no gerenciamento de funções e permissões de usuários	Potencial sobrecarga de desempenho com interações de banco de dados