S04L11 - Adicionar Autoridades à Conta de Usuário no Spring Boot

html

Melhorando a Gestão de Usuários: Adicionando Tabelas de Autoridade no Spring Boot
Índice

Introdução ........................................................... 1
Configurando a Entidade de Autoridade ............... 3
Criando o Repositório e Serviço de Autoridade ................................................................. 7
Definindo Privilégios com Enums .................. 11
Populando Dados Iniciais ......................................... 15
Estabelecendo Relacionamentos Muitos-para-Muitos .................................................................................................... 19
Conclusão ............................................................. 25


Introdução
Em aplicações web modernas, a gestão de usuários e a autorização são componentes críticos que garantem o acesso seguro aos recursos. Implementar um sistema de autoridade robusto permite que os desenvolvedores definam e gerenciem funções e privilégios de usuários de forma eficaz. Este eBook aborda o processo de adicionar tabelas de autoridade às contas de usuário em uma aplicação Spring Boot, aprimorando a segurança e a escalabilidade.
Importância da Gestão de Autoridade

Segurança: Restringe o acesso a funcionalidades sensíveis.
Escalabilidade: Facilita a adição de novas funções e privilégios.
Manutenibilidade: Simplifica a gestão das permissões dos usuários.

Prós e Contras


Prós
Contras


Melhoria na segurança e controle de acesso
A configuração inicial pode ser demorada


Gerenciamento fácil de funções e privilégios de usuários
Requer planejamento cuidadoso das funções e permissões


Aprimora a escalabilidade para expansões futuras
Potencial complexidade em aplicações maiores


Quando e Onde Usar

Aplicações Empresariais: Gerenciamento de funções de usuários diversificadas.
Plataformas de Comércio Eletrônico: Diferenciação entre clientes, fornecedores e administradores.
Sistemas de Gestão de Conteúdo: Controle de acesso à criação e edição de conteúdo.


Configurando a Entidade de Autoridade
Estabelecer a entidade Authority é fundamental para gerenciar as permissões dos usuários. Essa entidade geralmente contém um ID e um nome que representam diferentes autoridades.
Criando o Modelo de Autoridade




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.models;

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

@Entity
public class Authority {
    
    @Id
    private Long id;
    private String name;

    // Constructor
    public Authority(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    // Getters
    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    // Setters
    public void setId(Long id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }
}
			
				
					
				
					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
35
36
				
						package org.studyeasy.SpringBlog.models;
 
import javax.persistence.Entity;
import javax.persistence.Id;
 
@Entity
public class Authority {
    
    @Id
    private Long id;
    private String name;
 
    // Constructor
    public Authority(Long id, String name) {
        this.id = id;
        this.name = name;
    }
 
    // Getters
    public Long getId() {
        return id;
    }
 
    public String getName() {
        return name;
    }
 
    // Setters
    public void setId(Long id) {
        this.id = id;
    }
 
    public void setName(String name) {
        this.name = name;
    }
}
					
				
			
		


Explicação

@Entity: Marca a classe como uma entidade JPA.
@Id: Denota a chave primária.
Campos: id e name representam o identificador da autoridade e seu nome, respectivamente.
Construtor & Getters/Setters: Facilitam a criação de objetos e o acesso às propriedades.


Criando o Repositório e Serviço de Autoridade
Para interagir com a entidade Authority, precisamos criar uma camada de repository e um service.
Repositório de Autoridade




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.repositories;

import org.springframework.data.jpa.repository.JpaRepository;
import org.studyeasy.SpringBlog.models.Authority;

public interface AuthorityRepository extends JpaRepository<Authority, Long> {
}
			
				
					
				
					1
2
3
4
5
6
7
				
						package org.studyeasy.SpringBlog.repositories;
 
import org.springframework.data.jpa.repository.JpaRepository;
import org.studyeasy.SpringBlog.models.Authority;
 
public interface AuthorityRepository extends JpaRepository<Authority, Long> {
}
					
				
			
		


Serviço de Autoridade




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.services;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.repositories.AuthorityRepository;

@Service
public class AuthorityService {

    @Autowired
    private AuthorityRepository authorityRepository;

    public Authority save(Authority authority) {
        return authorityRepository.save(authority);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
				
						package org.studyeasy.SpringBlog.services;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.repositories.AuthorityRepository;
 
@Service
public class AuthorityService {
 
    @Autowired
    private AuthorityRepository authorityRepository;
 
    public Authority save(Authority authority) {
        return authorityRepository.save(authority);
    }
}
					
				
			
		


Explicação

AuthorityRepository: Extende JpaRepository para fornecer operações CRUD para a entidade Authority.
AuthorityService: Utiliza AuthorityRepository para gerenciar autoridades, encapsulando a lógica de negócios.


Definindo Privilégios com Enums
Enums são uma maneira eficiente de definir um conjunto fixo de constantes, como privilégios de usuários.
Criando o Enum de Privilégios




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.util.constants;

public enum Privileges {
    RESET_PASSWORD(1L, "RESET_PASSWORD"),
    ACCESS_ADMIN_PANEL(2L, "ACCESS_ADMIN_PANEL");

    private Long id;
    private String name;

    Privileges(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
				
						package org.studyeasy.SpringBlog.util.constants;
 
public enum Privileges {
    RESET_PASSWORD(1L, "RESET_PASSWORD"),
    ACCESS_ADMIN_PANEL(2L, "ACCESS_ADMIN_PANEL");
 
    private Long id;
    private String name;
 
    Privileges(Long id, String name) {
        this.id = id;
        this.name = name;
    }
 
    public Long getId() {
        return id;
    }
 
    public String getName() {
        return name;
    }
}
					
				
			
		


Explicação

Constantes Enum: RESET_PASSWORD e ACCESS_ADMIN_PANEL representam privilégios distintos.
Campos: Cada constante enum tem um id e um name.
Construtor & Getters: Facilitam a criação e a recuperação das propriedades dos privilégios.


Populando Dados Iniciais
Dados iniciais inicializam o banco de dados com autoridades padrão, garantindo que funções essenciais estejam disponíveis ao iniciar a aplicação.
Implementando Dados Iniciais




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.services.AuthorityService;
import org.studyeasy.SpringBlog.util.constants.Privileges;

@Component
public class SeedData implements CommandLineRunner {

    @Autowired
    private AuthorityService authorityService;

    @Override
    public void run(String... args) throws Exception {
        for (Privileges privilege : Privileges.values()) {
            Authority authority = new Authority();
            authority.setId(privilege.getId());
            authority.setName(privilege.getName());
            authorityService.save(authority);
        }
    }
}
			
				
					
				
					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
				
						package org.studyeasy.SpringBlog.config;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.services.AuthorityService;
import org.studyeasy.SpringBlog.util.constants.Privileges;
 
@Component
public class SeedData implements CommandLineRunner {
 
    @Autowired
    private AuthorityService authorityService;
 
    @Override
    public void run(String... args) throws Exception {
        for (Privileges privilege : Privileges.values()) {
            Authority authority = new Authority();
            authority.setId(privilege.getId());
            authority.setName(privilege.getName());
            authorityService.save(authority);
        }
    }
}
					
				
			
		


Explicação

@Component: Registra a classe como um bean Spring.
CommandLineRunner: Executa o método run após o início da aplicação.
Looping Através dos Privilégios: Itera sobre todos os valores do enum para criar e salvar as autoridades correspondentes.
Tratamento de Erros: Questões menores, como incompatibilidades de tipo, são resolvidas garantindo tipos de dados consistentes (Long vs. int).

Saída da Execução dos Dados Iniciais
Ao executar a aplicação, a tabela Authority é populada com os privilégios definidos:


ID
Name


1
RESET_PASSWORD


2
ACCESS_ADMIN_PANEL



Estabelecendo Relacionamentos Muitos-para-Muitos
Para associar usuários com múltiplas autoridades e vice-versa, estabelece-se um relacionamento muitos-para-muitos entre as entidades Account e Authority.
Atualizando o Modelo de Conta




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.models;

import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;

@Entity
public class Account {

    @Id
    private Long id;
    private String username;
    private String password;

    @ManyToMany
    @JoinTable(
        name = "account_authority",
        joinColumns = @JoinColumn(name = "account_id", referencedColumnName = "id"),
        inverseJoinColumns = @JoinColumn(name = "authority_id", referencedColumnName = "id")
    )
    private Set<Authority> authorities = new HashSet<>();

    // Constructors, Getters, and Setters
}
			
				
					
				
					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.SpringBlog.models;
 
import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;
 
@Entity
public class Account {
 
    @Id
    private Long id;
    private String username;
    private String password;
 
    @ManyToMany
    @JoinTable(
        name = "account_authority",
        joinColumns = @JoinColumn(name = "account_id", referencedColumnName = "id"),
        inverseJoinColumns = @JoinColumn(name = "authority_id", referencedColumnName = "id")
    )
    private Set<Authority> authorities = new HashSet<>();
 
    // Constructors, Getters, and Setters
}
					
				
			
		


Explicação

@ManyToMany: Define um relacionamento muitos-para-muitos entre Account e Authority.
@JoinTable: Especifica a tabela de junção account_authority que facilita o relacionamento.

joinColumns: Faz referência à entidade Account.
inverseJoinColumns: Faz referência à entidade Authority.


Set<Authority>: Utiliza um Set para evitar autoridades duplicadas para uma conta.

Criando a Tabela de Junção
A tabela de junção account_authority é criada automaticamente com base nas anotações, com a seguinte estrutura:


Nome da Coluna
Tipo de Dados
Restrições


account_id
Long
Chave estrangeira para Account.id


authority_id
Long
Chave estrangeira para Authority.id


Benefícios dos Relacionamentos Muitos-para-Muitos

Flexibilidade: Permite múltiplas autoridades por usuário e vice-versa.
Integridade dos Dados: Garante dados consistentes e não redundantes através da tabela de junção.


Conclusão
Implementar tabelas de autoridade em uma aplicação Spring Boot é fundamental para uma robusta gestão de usuários e autorização. Este guia abrangente abordou as etapas essenciais:

Configurando a Entidade de Autoridade: Estabelecendo uma entidade fundamental para representar funções de usuários.
Criando o Repositório e Serviço de Autoridade: Facilitando o acesso aos dados e a lógica de negócios.
Definindo Privilégios com Enums: Enumerando privilégios distintos de usuários para clareza e consistência.
Populando Dados Iniciais: Garantindo que funções essenciais sejam iniciadas ao iniciar a aplicação.
Estabelecendo Relacionamentos Muitos-para-Muitos: Habilitando associações flexíveis entre usuários e suas autoridades.

Seguindo estas etapas, os desenvolvedores podem criar um sistema de gestão de autoridade seguro e escalável dentro de suas aplicações Spring Boot.
Palavras-chave Otimizadas para SEO
Spring Boot authority tables, user management Spring Boot, Spring Boot authorization, many-to-many Spring Boot, Spring Boot security, defining privileges Spring Boot, Spring Boot seed data, Authority entity Spring Boot, Spring Boot user roles, Spring Boot application security
Nota: Este artigo é gerado por IA.
Prós	Contras
Melhoria na segurança e controle de acesso	A configuração inicial pode ser demorada
Gerenciamento fácil de funções e privilégios de usuários	Requer planejamento cuidadoso das funções e permissões
Aprimora a escalabilidade para expansões futuras	Potencial complexidade em aplicações maiores
Nome da Coluna	Tipo de Dados	Restrições
account_id	Long	Chave estrangeira para Account.id
authority_id	Long	Chave estrangeira para Authority.id