Início / coding / Perguntas / 79298921
Accepted
jesmith17
Asked: 2024-12-21 13:20:52 +0800 CST

@MappedSuperclass sendo atribuído a um @OneToMany spring-data

  • 772

Estou trabalhando em um aplicativo para rastrear contas de clientes. Cada cliente pode ter várias contas. O desafio é que o objeto de conta é polimórfico. Há uma classe abstrata Accountcom 2-3 métodos e, atualmente, há 2 subtipos SavingsAccounte CreditAccount.

O que tentei foi fazer com que o Accountobjeto usasse a @MappedSuperclassanotação e, então, cada classe concreta tivesse as @Entityanotações normalmente.

O problema parece ser o mapeamento do meu objeto Cliente

    @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
    @JoinColumn(name="customer_id", referencedColumnName = "id")
    List<Account> accounts = new ArrayList<>();

Quando uso isso, recebo um aviso do Spring no meu IDE, mas em tempo de execução recebo esse erro.

com.example.models.Customer.accounts' targets the type 'com.example.models.Account' which is not an '@Entity' type

Não há como ter um mapeamento @OneToMany contra uma lista de objetos polimórficos? Mesmo se eles estivessem armazenados na mesma tabela?

spring-data-jpa

1 respostas

  1. Best Answer

    @MappedSuperclassé usado para reutilizar propriedades comuns em @Entityclasses anotadas e não se aplica diretamente ao seu caso atual. No entanto, um exemplo de uso correto para @MappedSuperclassno seu caso seria:

    @MappedSuperclass
public abstract class MyMappedSuperclass {

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

    // getter/setter
}

    e deixe Customerherdar MyMappedSuperclass.

    Você precisa anotar sua Accountclasse base com @Entity and @Inheritance . Isso habilita consultas polimórficas, onde você pode consultar a classe base e recuperar todas as suas subclasses. Se estiver usando uma única tabela para todas as subclasses, a Accountclasse pode ficar assim:

    import jakarta.persistence.*;

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = "account_type")
public abstract class Account {

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

    @ManyToOne
    @JoinColumn(name = "customer_id", nullable = false)
    private Customer customer;

    // getters and setters
}

    Suas subclasses ficarão assim

    import jakarta.persistence.DiscriminatorValue;

@DiscriminatorValue("SAVINGS")
public class SavingsAccount extends Account {
}

@DiscriminatorValue("CREDIT")
public class CreditAccount extends Account {
}

    Verifiquei o código acima com esta implementação do Cliente:

    import jakarta.persistence.*;

import java.util.ArrayList;
import java.util.List;

@Entity
public class Customer {

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

    @OneToMany(mappedBy = "customer", cascade = CascadeType.ALL)
    private List<Account> accounts = new ArrayList<>();

    public void addAccount(Account account) {
        account.setCustomer(this);
        accounts.add(account);
    }

    // getters/setters
}

    Repositório do Cliente

    import org.springframework.data.repository.CrudRepository;

public interface CustomerRepository extends CrudRepository<Customer, Long> {
}

    Migração Flyway (Postgresql)

    CREATE TABLE customer
(
    id SERIAL PRIMARY KEY
);

CREATE TABLE account
(
    id           SERIAL PRIMARY KEY,
    account_type VARCHAR(16) NOT NULL,
    customer_id  INT         NOT NULL,
    CONSTRAINT fk_customer FOREIGN KEY (customer_id) REFERENCES customer (id)
);

    Configuração do contêiner de teste do Postgres

    import org.springframework.boot.test.context.TestConfiguration;
import org.springframework.boot.testcontainers.service.connection.ServiceConnection;
import org.springframework.context.annotation.Bean;
import org.testcontainers.containers.PostgreSQLContainer;

@TestConfiguration
public class PostgresTestContainerConfig {

    @Bean
    @ServiceConnection
    public PostgreSQLContainer<?> postgreSQLContainer() {
        return new PostgreSQLContainer<>("postgres:15-alpine");
    }
}

    Teste

    import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager;
import org.springframework.context.annotation.Import;

import static org.junit.jupiter.api.Assertions.*;

@DataJpaTest
@AutoConfigureTestDatabase
@Import(no.vicx.database.PostgresTestContainerConfig.class)
class CustomerRepositoryTest {

    @Autowired
    TestEntityManager entityManager;

    @Autowired
    CustomerRepository sut;

    @Test
    void testInserts() {
        Customer customer = new Customer();
        customer.addAccount(new SavingsAccount());
        customer.addAccount(new CreditAccount());

        sut.save(customer);

        assertEquals(2, getAccountCountInDb());

        var customerInDb = entityManager.find(Customer.class, customer.getId());

        assertInstanceOf(SavingsAccount.class, customerInDb.getAccounts().getFirst());
        assertInstanceOf(CreditAccount.class, customerInDb.getAccounts().getLast());
    }

    long getAccountCountInDb() {
        return (long) entityManager.getEntityManager()
                .createQuery("SELECT COUNT(1) FROM Account ")
                .getSingleResult();
    }
}
    • 0

relate perguntas