Spring Boot多数据源下JPA实体关联“未知实体”异常解析与解决方案

package com.student.application.domain.app1; // Flight实体所属包

import lombok.*;
import javax.persistence.*;
import java.io.Serializable;
import java.util.Date;

@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@Entity
@Table(schema = "app1")
public class Flight implements Serializable {
    @Id
    @GeneratedValue(
            strategy = GenerationType.SEQUENCE,
            generator = "flight_sequence"
    )
    @SequenceGenerator(
            name = "flight_sequence",
            allocationSize = 1
    )
    @Column(nullable = false, updatable = false)
    private Long id;

    private String callsign;

    // 不再直接关联Aircraft实体，而是存储其ID
    @Column(name="aircraft_id", nullable=false)
    private Long aircraftId; 

    private Date date;
    // ... 其他属性
    private String origin;
    private String destination;
}

// Aircraft实体（com.student.application.domain.app2.Aircraft）保持不变
// AircraftRepository（com.student.application.repository.app2.AircraftRepository）保持不变

package com.student.application.service;

import com.student.application.domain.app1.Flight;
import com.student.application.domain.app2.Aircraft;
import com.student.application.repository.app1.FlightRepository;
import com.student.application.repository.app2.AircraftRepository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.beans.factory.annotation.Qualifier;

import java.util.Optional;

@Service
public class FlightService {

    private final FlightRepository flightRepository;
    private final AircraftRepository aircraftRepository;

    public FlightService(
            FlightRepository flightRepository,
            @Qualifier("app2AircraftRepository") AircraftRepository aircraftRepository) { // 使用Qualifier明确指定Repository
        this.flightRepository = flightRepository;
        this.aircraftRepository = aircraftRepository;
    }

    @Transactional("app1TransactionManager") // 明确指定事务管理器
    public Flight findFlightWithAircraft(Long flightId) {
        Optional<Flight> flightOptional = flightRepository.findById(flightId);
        if (flightOptional.isPresent()) {
            Flight flight = flightOptional.get();
            // 根据aircraftId手动查询Aircraft信息
            Optional<Aircraft> aircraftOptional = aircraftRepository.findById(flight.getAircraftId());
            aircraftOptional.ifPresent(aircraft -> {
                // 这里可以创建一个DTO或扩展Flight实体，将Aircraft信息包含进去
                // 例如，如果FlightDTO包含Aircraft信息
                // flight.setAircraftDetails(aircraft); // 假设Flight有一个方法可以设置Aircraft对象
            });
            return flight;
        }
        return null;
    }

    // 对于FlightRepository中的查询方法，需要调整以适应新的模型
    // 例如，如果需要根据Aircraft的注册号查询Flight，则需要先查询Aircraft的ID
    @Transactional("app1TransactionManager")
    public Flight findFlightByDestinationAndAircraftRegistration(String destination, String registration) {
        // 1. 首先通过app2EntityManager管理的AircraftRepository查询Aircraft ID
        Optional<Aircraft> aircraftOptional = aircraftRepository.findByRegistration(registration); // 假设AircraftRepository有此方法
        if (aircraftOptional.isPresent()) {
            Long aircraftId = aircraftOptional.get().getId();
            // 2. 然后通过app1EntityManager管理的FlightRepository查询Flight
            // FlightRepository需要一个新的查询方法，例如：
            // Flight findFirstByDestinationAndAircraftIdOrderByDateDesc(String destination, Long aircraftId);
            return flightRepository.findFirstByDestinationAndAircraftIdOrderByDateDesc(destination, aircraftId);
        }
        return null;
    }
}

package com.student.application.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.transaction.PlatformTransactionManager;

import javax.sql.DataSource;
import java.util.HashMap;

@Configuration
@PropertySource({"classpath:application.properties"})
@EnableJpaRepositories(
        basePackages = "com.student.application.repository.app1",
        entityManagerFactoryRef = "app1EntityManager",
        transactionManagerRef = "app1TransactionManager")
public class App1DBConfiguration {
    @Autowired
    private Environment env;

    @Primary
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource")
    public DataSource app1DataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean
    @Primary
    public LocalContainerEntityManagerFactoryBean app1EntityManager() {
        LocalContainerEntityManagerFactoryBean em
                = new LocalContainerEntityManagerFactoryBean();
        em.setDataSource(app1DataSource());
        // 关键修改：添加Aircraft实体所在的包
        em.setPackagesToScan(
                "com.student.application.domain.app1",
                "com.student.application.domain.app2"); // 添加Aircraft所在的包

        HibernateJpaVendorAdapter vendorAdapter
                = new HibernateJpaVendorAdapter();
        em.setJpaVendorAdapter(vendorAdapter);
        HashMap<String, Object> properties = new HashMap<>();
        properties.put("hibernate.hbm2ddl.auto",
                env.getProperty("spring.jpa.hibernate.ddl-auto"));
        properties.put("hibernate.dialect",
                env.getProperty("spring.jpa.properties.hibernate.dialect"));
        properties.put("hibernate.dialect.storage_engine",
                env.getProperty("spring.jpa.properties.hibernate.dialect.storage_engine"));
        em.setJpaPropertyMap(properties);

        return em;
    }

    @Primary
    @Bean
    public PlatformTransactionManager app1TransactionManager() {
        JpaTransactionManager transactionManager
                = new JpaTransactionManager();
        transactionManager.setEntityManagerFactory(
                app1EntityManager().getObject());
        return transactionManager;
    }
}

package com.student.application.domain.app1;

import lombok.*;
import javax.persistence.*;
import java.io.Serializable;
import java.util.Date;

@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@Entity
@Table(schema = "app1")
public class Flight implements Serializable {
    @Id
    @GeneratedValue(
            strategy = GenerationType.SEQUENCE,
            generator = "flight_sequence"
    )
    @SequenceGenerator(
            name = "flight_sequence",
            allocationSize = 1
    )
    @Column(nullable = false, updatable = false)
    private Long id;

    private String callsign;
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name="aircraft_id", nullable=false)
    private Aircraft aircraft; // 直接关联Aircraft实体
    private Date date;
    // ... 其他属性
    private String origin;
    private String destination;
}