{"id":22930442,"url":"https://github.com/patinaomi/projeto-spring-java","last_synced_at":"2026-05-10T19:15:10.298Z","repository":{"id":262184182,"uuid":"846783520","full_name":"patinaomi/projeto-spring-java","owner":"patinaomi","description":"Projeto realizado durante o curso de Spring da Udemy","archived":false,"fork":false,"pushed_at":"2024-12-16T02:55:52.000Z","size":1587,"stargazers_count":0,"open_issues_count":0,"forks_count":0,"subscribers_count":1,"default_branch":"main","last_synced_at":"2025-04-01T17:20:53.645Z","etag":null,"topics":["java","javaee","spring","spring-boot"],"latest_commit_sha":null,"homepage":"","language":"Java","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/patinaomi.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2024-08-24T00:29:32.000Z","updated_at":"2024-12-16T02:55:56.000Z","dependencies_parsed_at":"2024-11-11T03:31:05.126Z","dependency_job_id":"32082049-a89a-4765-83e1-28fb47264d1d","html_url":"https://github.com/patinaomi/projeto-spring-java","commit_stats":null,"previous_names":["patinaomi/projeto-spring-java"],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/patinaomi/projeto-spring-java","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/patinaomi%2Fprojeto-spring-java","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/patinaomi%2Fprojeto-spring-java/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/patinaomi%2Fprojeto-spring-java/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/patinaomi%2Fprojeto-spring-java/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/patinaomi","download_url":"https://codeload.github.com/patinaomi/projeto-spring-java/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/patinaomi%2Fprojeto-spring-java/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":32868265,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-10T13:40:02.631Z","status":"ssl_error","status_checked_at":"2026-05-10T13:40:02.145Z","response_time":54,"last_error":"SSL_connect returned=1 errno=0 peeraddr=140.82.121.5:443 state=error: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["java","javaee","spring","spring-boot"],"created_at":"2024-12-14T10:28:07.231Z","updated_at":"2026-05-10T19:15:10.280Z","avatar_url":"https://github.com/patinaomi.png","language":"Java","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Revisão Conteúdo Spring\n\n## Arquitetura de Projeto\n### Domains\nAs domains são o núcleo da aplicação, representa as regras de negócio e lógica principal. É onde ficam as \"entidades\" que descrevem os principais conceitos do sistema. Exemplo: Cliente, Pedido, Produto etc.\n\n#### Mapeamento das entidades\n1. **@OneToOne** - Uma entidade está associada a apenas uma outra entidade e vice-versa.\nEx: Um usuário tem um único perfil e cada perfil pertence a apenas um usuário.\n\n```\n@OneToOne\n@JoinColumn(name = \"perfil_id\")\nprivate Perfil perfil;\n```\n\n2. **@OneToMany** - Uma entidade está associada a várias instâncias de outra entidade, mas cada instância dessa outra entidade pertence a apenas uma instância da primeira.\nEx: Um Estado pode ter muitos Enderecos, mas cada Endereco pertence a um único estado.\n``` \n@OneToMany(mappedBy = \"estado\") //Tem que colocar o nome da Classe e não o da tabela!\nprivate List\u003cEndereco\u003e enderecos;\n```\n3. **@ManyToOne** - Um relacionamento onde muitas instâncias de uma entidade podem estar associadas a uma única instância de outra entidade.\nEx: Vários Endereços podem estar associados a um único Estado.\n```\n@ ManyToOne\n@JoinColumn(name = \"estado_id)\nprivate Estado estado;\n```\n4. **@ManyToMany -** Várias instâncias de uma entidade podem estar associadas a várias instâncias de outra entidade. \n```\n@ManyToMany\n@JoinTable(name = \"produto_categoria\",\n           joinColumns = @JoinColumn(name = \"produto_id\"),\n           inverseJoinColumns = @JoinColumn(name = \"categoria_id\"))\nprivate List\u003cCategoria\u003e categorias;\n```\n**MappedBy**  -  Colocamos no lado não proprietário, ou seja no lado que não possui chave estrangeira. \n\n---\n## Bibliotecas\n### Lombok\nO Lombok serve para reduzir verbosidade de código boilerplate utilizando anotações para gerar automaticamente construtores, getters, setters, equals, hashcode, toString, etc.\n\nData - gera construtores, equals, hashcode\nAll Args Constructor - Gera um construtor com todos os parâmetros\nNo Args Constructor - Gera um consrutor sem os parâmetros\nRequired Args Constructor - Escolher quais campos serão passados no construtor\n\n    import lombok.RequiredArgsConstructor;\n    \n    @RequiredArgsConstructor\n    public class Exemplo {\n        private final String nome; // Lombok incluirá esse campo no construtor gerado\n        private int idade; // Não será incluído no construtor\n    }\n\nEquals and HashCode - Usado quando queremos comparar classes por valor. Ver sempre quais campos precisam ser incluídos para evitar problemas de performance.\n\n\n    import lombok.EqualsAndHashCode;\n    \n    @EqualsAndHashCode(onlyExplicitlyIncluded = true)\n    public class Pessoa {\n        @EqualsAndHashCode.Include\n        private String nome;\n    \n        private int idade;\n    }\n\n### Mapper\n**`@Mapper(componentModel = MappingConstants.ComponentModel.SPRING)`**: Configura o MapStruct para gerar uma implementação que será gerenciada pelo Spring, permitindo a injeção de `CategoriaMapper` como um bean do Spring.\n\n```@Mapper(componentModel = MappingConstants.ComponentModel.SPRING)  \npublic interface CategoriaMapper {  \n  \n  Categoria map(CategoriaRequest request);  \n  CategoriaResponse map(Categoria categoria);  \n  \n} \n```\n\n**Métodos `map`**:\n\n-   `Categoria map(CategoriaRequest request)`: Mapeia de `CategoriaRequest` para `Categoria`, ideal para criação ou atualização.\n-   `CategoriaResponse map(Categoria categoria)`: Mapeia de `Categoria` para `CategoriaResponse`, ideal para retornar dados ao cliente da API.\n- \n### Como Utilizar o Serviço de Log\n\nGeralmente, o logging em Java é feito usando uma biblioteca como **SLF4J** com **Logback** ou **Log4j**, ou, em algumas aplicações, utilizando diretamente o serviço de log fornecido pelo framework, como o `Logger` no Spring Boot.\n\n1.  **Injetando o Logger**: No Spring, você pode usar a anotação `@Slf4j` (de `Lombok`) para criar automaticamente um logger. Se não estiver usando Lombok, pode criar uma instância de logger manualmente.\n\n### Padrão de Arquitetura e Padrão de Projeto\n\n-   **Padrão de Arquitetura** é um nível mais alto de organização do sistema. Ele define como os diferentes componentes do sistema interagem entre si e estabelece a estrutura geral do software. Exemplos incluem arquiteturas como **MVC (Model-View-Controller)**, **Microservices**, **Monolítica**, e **Clean Architecture**. O foco é na estrutura global do sistema e em como ele se conecta e se organiza para suportar requisitos funcionais e não funcionais.\n    \n-   **Padrão de Projeto** (ou Design Pattern) é um nível mais específico e trata de soluções para problemas recorrentes no código em si. Ele ajuda na organização do código e na criação de componentes reutilizáveis, mas não define a estrutura global do sistema. Exemplos clássicos incluem **Singleton**, **Factory**, **Observer**, e **Builder**. O foco está em resolver problemas específicos de implementação e organização do código.\nA anotação `@Inheritance(strategy = InheritanceType.JOINED)` em JPA é usada para definir uma **estratégia de herança** entre classes de entidades no banco de dados. Essa anotação é aplicada em uma classe de entidade pai (ou superclasse), indicando que suas subclasses serão armazenadas em tabelas separadas, mas ligadas por uma relação de chave estrangeira.\n\n### Como Funciona a Estratégia `JOINED`\n\nCom `InheritanceType.JOINED`, o JPA armazena:\n\n-   A entidade pai em uma tabela.\n-   Cada subclasse em uma tabela separada.\n\nAs tabelas das subclasses têm uma **chave estrangeira** que referencia a chave primária da tabela da entidade pai. Isso permite que o JPA construa e recupere as subclasses com um **JOIN** entre as tabelas.\n\n### Exemplo de Uso\n\nSuponha que você tenha uma hierarquia de classes onde `Pagamento` é a classe pai, e `PagamentoComCartao` e `PagamentoComBoleto` são subclasses.\n\n#### Classe Pai `Pagamento`\n\njava\n\nCopiar código\n\n`import jakarta.persistence.Entity;\nimport jakarta.persistence.Id;\nimport jakarta.persistence.Inheritance;\nimport jakarta.persistence.InheritanceType;\n\n@Entity\n@Inheritance(strategy = InheritanceType.JOINED)\npublic abstract class Pagamento {\n\n    @Id\n    private Long id;\n    private Double valor;\n\n    // Getters e Setters\n}` \n\n#### Subclasse `PagamentoComCartao`\n\njava\n\nCopiar código\n\n`import jakarta.persistence.Entity;\n\n@Entity\npublic class PagamentoComCartao extends Pagamento {\n\n    private Integer numeroDeParcelas;\n\n    // Getters e Setters\n}` \n\n#### Subclasse `PagamentoComBoleto`\n\njava\n\nCopiar código\n\n`import jakarta.persistence.Entity;\nimport java.time.LocalDate;\n\n@Entity\npublic class PagamentoComBoleto extends Pagamento {\n\n    private LocalDate dataVencimento;\n    private LocalDate dataPagamento;\n\n    // Getters e Setters\n}` \n\n### Estrutura de Tabelas no Banco de Dados\n\nUsando `@Inheritance(strategy = InheritanceType.JOINED)`, o JPA cria três tabelas:\n\n1.  **Tabela `Pagamento`** (entidade pai):\n    \n    -   Colunas: `id`, `valor`\n2.  **Tabela `PagamentoComCartao`** (subclasse):\n    \n    -   Colunas: `id`, `numeroDeParcelas`\n    -   `id` é uma chave estrangeira para a tabela `Pagamento`.\n3.  **Tabela `PagamentoComBoleto`** (subclasse):\n    \n    -   Colunas: `id`, `dataVencimento`, `dataPagamento`\n    -   `id` é uma chave estrangeira para a tabela `Pagamento`.\n\n### Vantagens e Desvantagens\n\n#### Vantagens\n\n-   **Normalização de Dados**: Evita a redundância de dados, pois os atributos comuns ficam na tabela pai.\n-   **Flexibilidade para Consultas**: Permite consultar apenas as colunas da entidade pai (`Pagamento`), ou as colunas da subclasse específica (`PagamentoComCartao` ou `PagamentoComBoleto`) usando JOINs.\n\n#### Desvantagens\n\n-   **Performance**: Requer JOINs para buscar subclasses, o que pode afetar a performance em consultas complexas.\n-   **Complexidade de Design**: Estruturas de JOIN podem ser complexas em heranças muito profundas.\n\n### Quando Usar `InheritanceType.JOINED`\n\nUse `InheritanceType.JOINED` quando você quer **evitar a duplicação de dados** entre subclasses e **preservar a normalização** no banco de dados. É útil quando as subclasses possuem dados distintos e você precisa de uma estrutura de banco bem organizada.\n\nA anotação `@Inheritance(strategy = InheritanceType.JOINED)` em JPA é usada para definir uma **estratégia de herança** entre classes de entidades no banco de dados. Essa anotação é aplicada em uma classe de entidade pai (ou superclasse), indicando que suas subclasses serão armazenadas em tabelas separadas, mas ligadas por uma relação de chave estrangeira.\n\n### Como Funciona a Estratégia `JOINED`\n\nCom `InheritanceType.JOINED`, o JPA armazena:\n\n-   A entidade pai em uma tabela.\n-   Cada subclasse em uma tabela separada.\n\nAs tabelas das subclasses têm uma **chave estrangeira** que referencia a chave primária da tabela da entidade pai. Isso permite que o JPA construa e recupere as subclasses com um **JOIN** entre as tabelas.\n\n### Exemplo de Uso\n\nSuponha que você tenha uma hierarquia de classes onde `Pagamento` é a classe pai, e `PagamentoComCartao` e `PagamentoComBoleto` são subclasses.\n\n#### Classe Pai `Pagamento`\n\njava\n\nCopiar código\n\n`import jakarta.persistence.Entity;\nimport jakarta.persistence.Id;\nimport jakarta.persistence.Inheritance;\nimport jakarta.persistence.InheritanceType;\n\n@Entity\n@Inheritance(strategy = InheritanceType.JOINED)\npublic abstract class Pagamento {\n\n    @Id\n    private Long id;\n    private Double valor;\n\n    // Getters e Setters\n}` \n\n#### Subclasse `PagamentoComCartao`\n\njava\n\nCopiar código\n\n`import jakarta.persistence.Entity;\n\n@Entity\npublic class PagamentoComCartao extends Pagamento {\n\n    private Integer numeroDeParcelas;\n\n    // Getters e Setters\n}` \n\n#### Subclasse `PagamentoComBoleto`\n\njava\n\nCopiar código\n\n`import jakarta.persistence.Entity;\nimport java.time.LocalDate;\n\n@Entity\npublic class PagamentoComBoleto extends Pagamento {\n\n    private LocalDate dataVencimento;\n    private LocalDate dataPagamento;\n\n    // Getters e Setters\n}` \n\n### Estrutura de Tabelas no Banco de Dados\n\nUsando `@Inheritance(strategy = InheritanceType.JOINED)`, o JPA cria três tabelas:\n\n1.  **Tabela `Pagamento`** (entidade pai):\n    \n    -   Colunas: `id`, `valor`\n2.  **Tabela `PagamentoComCartao`** (subclasse):\n    \n    -   Colunas: `id`, `numeroDeParcelas`\n    -   `id` é uma chave estrangeira para a tabela `Pagamento`.\n3.  **Tabela `PagamentoComBoleto`** (subclasse):\n    \n    -   Colunas: `id`, `dataVencimento`, `dataPagamento`\n    -   `id` é uma chave estrangeira para a tabela `Pagamento`.\n\n### Vantagens e Desvantagens\n\n#### Vantagens\n\n-   **Normalização de Dados**: Evita a redundância de dados, pois os atributos comuns ficam na tabela pai.\n-   **Flexibilidade para Consultas**: Permite consultar apenas as colunas da entidade pai (`Pagamento`), ou as colunas da subclasse específica (`PagamentoComCartao` ou `PagamentoComBoleto`) usando JOINs.\n\n#### Desvantagens\n\n-   **Performance**: Requer JOINs para buscar subclasses, o que pode afetar a performance em consultas complexas.\n-   **Complexidade de Design**: Estruturas de JOIN podem ser complexas em heranças muito profundas.\n\n### Quando Usar `InheritanceType.JOINED`\n\nUse `InheritanceType.JOINED` quando você quer **evitar a duplicação de dados** entre subclasses e **preservar a normalização** no banco de dados. É útil quando as subclasses possuem dados distintos e você precisa de uma estrutura de banco bem organizada.\n\n4o\n\n##### Você disse:\n\n@OneToOne(cascade = CascadeType.ALL, mappedBy = \"pedido\") e esse cascade?\n\n###### O ChatGPT disse:\n\nChatGPT\n\nA anotação `@OneToOne(cascade = CascadeType.ALL, mappedBy = \"pedido\")` configura um relacionamento de **um-para-um** em JPA, onde a entidade anotada possui uma relação direta com outra entidade. O `cascade = CascadeType.ALL` significa que todas as operações (como persistência, atualização e remoção) feitas em uma entidade também serão realizadas na entidade associada. Vou explicar cada parte em detalhes:\n\n### Explicação dos Atributos\n\n1.  **`@OneToOne`**: Define um relacionamento de um-para-um entre duas entidades.\n    \n2.  **`cascade = CascadeType.ALL`**:\n    \n    -   O atributo `cascade` controla o comportamento de propagação das operações entre as entidades associadas.\n    -   Com `CascadeType.ALL`, qualquer operação feita na entidade principal será automaticamente aplicada à entidade associada. Isso inclui:\n        -   **`PERSIST`**: Ao salvar a entidade principal, a entidade relacionada também será salva.\n        -   **`MERGE`**: Ao atualizar a entidade principal, a entidade relacionada também será atualizada.\n        -   **`REMOVE`**: Ao remover a entidade principal, a entidade relacionada também será removida.\n        -   **`REFRESH`**: Ao atualizar a entidade principal a partir do banco, a entidade relacionada também será atualizada.\n        -   **`DETACH`**: Ao separar a entidade principal do contexto de persistência, a entidade relacionada também será separada.\n3.  **`mappedBy = \"pedido\"`**:\n    \n    -   O atributo `mappedBy` indica que este lado do relacionamento é o **lado inverso** ou **não proprietário**.\n    -   `pedido` refere-se ao nome do campo na entidade oposta que é o proprietário do relacionamento. Nesse caso, a entidade associada tem um campo chamado `pedido`, que é o lado proprietário do relacionamento.\n\n### Exemplo de Uso\n\nVamos considerar um exemplo com as entidades `Pedido` e `Pagamento`, onde um `Pedido` possui um `Pagamento` associado.\n\n#### Classe `Pedido`\n\njava\n\nCopiar código\n\n`import jakarta.persistence.Entity;\nimport jakarta.persistence.Id;\nimport jakarta.persistence.OneToOne;\n\n@Entity\npublic class Pedido {\n\n    @Id\n    private Long id;\n\n    @OneToOne(mappedBy = \"pedido\", cascade = CascadeType.ALL)\n    private Pagamento pagamento;\n\n    // Getters e Setters\n}` \n\n#### Classe `Pagamento`\n\njava\n\nCopiar código\n\n`import jakarta.persistence.Entity;\nimport jakarta.persistence.Id;\nimport jakarta.persistence.JoinColumn;\nimport jakarta.persistence.OneToOne;\n\n@Entity\npublic class Pagamento {\n\n    @Id\n    private Long id;\n\n    @OneToOne\n    @JoinColumn(name = \"pedido_id\") // Define a chave estrangeira na tabela Pagamento\n    private Pedido pedido;\n\n    // Getters e Setters\n}` \n\n### O Que `CascadeType.ALL` Faz Neste Contexto?\n\n1.  **Ao Salvar um Pedido (`Pedido`)**:\n    \n    -   Se `Pagamento` estiver associado ao `Pedido`, ele também será salvo automaticamente, sem a necessidade de salvá-lo explicitamente.\n2.  **Ao Excluir um Pedido**:\n    \n    -   O `Pagamento` associado será excluído automaticamente.\n3.  **Ao Atualizar um Pedido**:\n    \n    -   Qualquer alteração no `Pagamento` associado também será automaticamente refletida.\n\n### Vantagens e Cuidados\n\n-   **Vantagens**: O `CascadeType.ALL` simplifica operações em relacionamentos, garantindo que as entidades relacionadas sejam automaticamente atualizadas, removidas ou persistidas conforme necessário.\n-   **Cuidados**: Use `CascadeType.ALL` apenas quando fizer sentido que as operações de uma entidade sejam refletidas na outra. Em relacionamentos onde a entidade relacionada precisa ser independente, evite esse tipo de cascata, pois pode causar exclusões acidentais.\n\nEm resumo, `CascadeType.ALL` garante que todas as operações realizadas na entidade principal também afetem a entidade associada, o que é útil em relacionamentos onde as entidades estão intimamente ligadas.\n\n-   **`@Embeddable`** é ideal para representar **tipos de dados compostos** ou **grupos de atributos relacionados**.\n-   A classe anotada com `@Embeddable` é incorporada em outra entidade usando a anotação `@Embedded`.\n\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fpatinaomi%2Fprojeto-spring-java","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fpatinaomi%2Fprojeto-spring-java","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fpatinaomi%2Fprojeto-spring-java/lists"}