@Entity
@Table(name="employees")
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = "type", discriminatorType = DiscriminatorType.STRING)
@DiscriminatorValue(value="employee")
public class Employee {
    @Id
    @GeneratedValue
    private Long id;
    private String name;
...

@Repository
public interface EmployeeRepository<T extends Employee> extends JpaRepository<T, Long> {
}

@Service
public class EmployeeService {
    @Autowired
    private EmployeeRepository<Employee> employeeRepo;
    @Autowired
    private EmployeeRepository<RegularEmployee> regularRepo;
    @Autowired
    private EmployeeRepository<ContractEmployee> contractRepo;
    public List<Employee> getAllEmployee() {
        return employeeRepo.findAll();
    }
    public List<RegularEmployee> getAllRegularEmployee(){
        return regularRepo.findAll();
    }
    public List<ContractEmployee> getAllContractEmployee() {
        return contractRepo.findAll();
    }
...

在`EmployeeRepository`中，一种选择是使用`@Query`：
```java
public interface EmployeeRepository<T extends Employee> extends JpaRepository<T, Long> {
    @Query("from RegularEmployee")
    List<RegularEmployee> findAllRegularEmployees();
}

public interface RegularEmployeeRepository extends EmployeeRepository<RegularEmployee> {}

@Service
public class EmployeeService {
    @Autowired EmployeeRepository<Employee> employeeRepo;
    @Autowired EmployeeRepository<RegularEmployee> regularRepoT;
    @Autowired RegularEmployeeRepository regularRepo;
    @PostConstruct
    public void init(){
        employeeRepo.save(new ContractEmployee("Mark"));
        employeeRepo.save(new RegularEmployee("Luke"));
        employeeRepo.findAll().forEach(System.out::println); // 打印 Mark 和 Luke
        regularRepo.findAll().forEach(System.out::println); // 仅打印 Luke
        regularRepoT.findAllRegularEmployees().forEach(System.out::println); // 仅打印 Luke
    }
    //...
}

注意：代码中的一些符号可能在显示上会有差异，但我已经尽力保留了原始代码的结构和内容。如果需要进一步的帮助，请随时提问。
<details>
<summary>英文:</summary>
One option is to use `@Query` in `EmployeeRepository`:
    public interface EmployeeRepository&lt;T extends Employee&gt; extends JpaRepository&lt;T, Long&gt; {
        @Query(&quot;from RegularEmployee&quot;)
        List&lt;RegularEmployee&gt; findAllRegularEmployees();
    }
A second option is to create an additional repository for each subclass of `Employee`. For `RegularEmployee` would be:
    public interface RegularEmployeeRepository extends EmployeeRepository&lt;RegularEmployee&gt;{}
This is how to use both options in `EmployeeService`:
    @Service
    public class EmployeeService {
        @Autowired EmployeeRepository&lt;Employee&gt; employeeRepo;
        @Autowired EmployeeRepository&lt;RegularEmployee&gt; regularRepoT;
    
        @Autowired RegularEmployeeRepository regularRepo;
    
        @PostConstruct
        public void init(){
            employeeRepo.save(new ContractEmployee(&quot;Mark&quot;));
            employeeRepo.save(new RegularEmployee(&quot;Luke&quot;));
            employeeRepo.findAll().forEach(System.out::println); // prints Mark and Luke
            regularRepo.findAll().forEach(System.out::println); // prints only Luke
            regularRepoT.findAllRegularEmployees().forEach(System.out::println); // prints only Luke
        }
    //...
    }
Also you can omit `@Repository` on top of `EmployeeRepository`. Spring already knows that is a Repository because it extends `JpaRepository`.
**Side note**: if you don&#39;t need `EmployeeRepository` to be created by Spring add `@NoRepositoryBean` on top of its class.
  [1]: https://docs.spring.io/spring-data/jpa/docs/current/reference/html/#jpa.query.spel-expressions
</details>
# 答案2
**得分**: 1
我已经能够使用您的通用EmployeeRepository复制您遇到的问题。作为一种替代方法，我创建了两个单独的存储库：ContractualEmployeeRepository和RegularEmployeeRepository。
```java
public interface ContractualEmployeeRepository extends JpaRepository<ContractualEmployee, String> {
}
public interface RegularEmployeeRepository extends JpaRepository<RegularEmployee, String> {
}

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {Main.class})
@TestExecutionListeners({DependencyInjectionTestExecutionListener.class,
        TransactionalTestExecutionListener.class,
        DbUnitTestExecutionListener.class})
@TestPropertySource(locations="classpath:application-test.properties")
@DatabaseSetup("classpath:SingleTableDataSet.xml")
public class IntegrationTest {
    @Autowired
    private RegularEmployeeRepository regularEmployeeRepository;
    @Autowired
    private ContractualEmployeeRepository contractualEmployeeRepository;
    @Test
    public void test() {
        Assert.assertEquals(6, regularEmployeeRepository.findAll().size());
        Assert.assertEquals(4, contractualEmployeeRepository.findAll().size());
    }
}