org.junit.jupiter.api.AfterEach#org.springframework.data.jpa.repository.JpaRepository源码实例Demo

private List<Long> ignoredValidate(List<Long> ignoredList, JpaRepository<?, Long> repository) {

        List<Long> invalids = new ArrayList<>();
        if (ignoredList != null && !ignoredList.isEmpty()) {

            for (Long ignored : ignoredList) {

                Object o = repository.findOne(ignored);
                if (o == null) {
                    invalids.add(ignored);
                }
            }
        }

        return invalids;
    }
 

/**
 * Creates a simple mock for a {@link JpaRepository} that mocks the
 * {@link JpaRepository#getOne(java.io.Serializable)} to return a base
 * entity that only has its id set.
 *
 * @param <U> type of repository
 * @param <T> type of repository entity
 * @param repositoryClass class of repository to be created
 * @param entityClass class of the entity to be created and returned by that mock
 * @param id the id that will be set on the created entity
 * @return
 */
static public <U extends JpaRepository<T, Long>, T extends BaseEntity> U getJpaRepositoryMockForGetOne(Class<U> repositoryClass, Class<T> entityClass, Long id) {

    try {
        T baseEntity = entityClass.newInstance();
        baseEntity.setId(id);

        U mock = mock(repositoryClass);
        when(mock.getOne(id)).thenReturn(baseEntity);

        return mock;

    } catch (IllegalAccessException | InstantiationException e) {
        throw new RuntimeException("Can't create mock for repository", e);
    }
}
 

/**
 * Page query by unit type.
 * 
 * @param req
 * @param unitType
 * @return
 */
public <T> CommonResponse find(UnitQueryPageReq<String> req, String unitType) {
    String repositoryName = StringUtils.uncapitalize(req.getUnitName() + unitType);
    if (repositoryService.getRepository(repositoryName).isPresent()) {
        JpaRepository j = repositoryService.getRepository(repositoryName).get();
        Page<T> page = j.findAll(req.convert());
        CommonPageRes<T> ret = new CommonPageRes<>(req);
        ret.setResult(page.getContent()).setTotalCount(page.getTotalElements()).setPageNo(req.getPageNo())
                .setPageSize(req.getPageSize());
        return ResponseUtils.data(ret);
    } else {
        return ResponseUtils.paramError("The unit name is invalid: " + req.getUnitName());
    }
}
 

public Optional<JpaRepository> getRepository(String name) {
    for (String k : repositories.keySet()) {
        if (name.equalsIgnoreCase(k)) {
            return Optional.of(repositories.get(k));
        }
    }
    return Optional.empty();
}
 

@BuildStep
void contributeClassesToIndex(BuildProducer<AdditionalIndexedClassesBuildItem> additionalIndexedClasses) {
    // index the Spring Data repository interfaces that extend Repository because we need to pull the generic types from it
    additionalIndexedClasses.produce(new AdditionalIndexedClassesBuildItem(
            Repository.class.getName(),
            CrudRepository.class.getName(),
            PagingAndSortingRepository.class.getName(),
            JpaRepository.class.getName(),
            QueryByExampleExecutor.class.getName()));
}
 

public static <T, R extends JpaRepository<T, ?> & JpaSpecificationExecutor>
SpecificationBuilder<T> selectFrom(R repository) {
    SpecificationBuilder<T> builder = new SpecificationBuilder<>();
    builder.repository = repository;
    builder.specification = new SpecificationImpl();
    return builder;
}
 

protected <T, ID extends Serializable> JpaRepository<?, ?> getTargetRepository(
		RepositoryMetadata metadata, EntityManager entityManager) {

	Class<?> repositoryInterface = metadata.getRepositoryInterface();
	JpaEntityInformation<?, Serializable> entityInformation = getEntityInformation(metadata.getDomainType());

	SimpleJpaRepository<?, ?> repo;
	if (JooqQueryExecutor.class.isAssignableFrom(repositoryInterface)) {
		repo = new JooqJpaRepository(entityInformation, entityManager, jooq);
	} else {
		repo = new SimpleJpaRepository(entityInformation, entityManager);
	}
	repo.setLockMetadataProvider(LockModeRepositoryPostProcessor.INSTANCE.getLockMetadataProvider());
	return repo;
}
 

@Override
public JpaRepository<Orderdao, Integer> repository(){
    return      repository;
}
 

@Override
public JpaRepository<User, String> repository() {
    return repository;
}
 

@AfterEach
public void clearRepositories() {
    repositories.forEach(JpaRepository::deleteAllInBatch);
}
 

public static <T, R extends JpaRepository<T, ?> & JpaSpecificationExecutor>
SpecificationBuilder<T> selectDistinctFrom(R repository) {
    SpecificationBuilder<T> builder = selectFrom(repository);
    builder.distinct();
    return builder;
}
 

@Override
protected JpaRepository getRepository() {
    return verifyCodeRepository;
}
 

@Override
protected JpaRepository getRepository() {
    return menuRepository;
}
 

@Override
protected JpaRepository getRepository() {
    return articleTemplateRepository;
}
 

@Override
protected JpaRepository getRepository() {
    return articleRepository;
}
 

@Override
protected JpaRepository getRepository() {
    return adRepository;
}
 

@Override
protected JpaRepository getRepository() {
    return tagsRepository;
}
 

@Override
protected JpaRepository getRepository() {
    return keyDataRepository;
}
 

@Override
protected JpaRepository getRepository() {
    return systemLogRepository;
}
 

@Override
protected JpaRepository getRepository() {
    return accountRepository;
}
 

@Override
protected JpaRepository getRepository() {
    return fansRepository;
}
 

public AbstractRepository(
        JpaRepository<T, ID> springRepository,
        JpaSpecificationExecutor<T> springSpecificationsExecutor) {
    this.springRepository = springRepository;
    this.springSpecificationsExecutor = springSpecificationsExecutor;
}
 

@Override
public JpaRepository repository() {
    return repository;
}
 

@Override
public JpaRepository repository() {
    return repository;
}
 

@Override
public JpaRepository repository() {
    return kerberosConfigRepository;
}
 

@Override
public JpaRepository repository() {
    return ldapConfigRepository;
}
 

@Override
public JpaRepository<Resource, Long> repository() {
    return repository;
}
 

/**
 * 无查询条件，进行分页查询。
 * findAll() 方法，会进行两次查询，先做 count 查询，之后是具体查询，所以 Page 中包含了总数和具体查询结果集
 * <p>
 * 仅是 repository 类型不同，没有和上一个方法合并
 *
 * @param repository    查询器，必须是 extends JpaRepository<???, Long>, JpaSpecificationExecutor 类型的写法。
 * @param currentPageNo 当前页，起始页为 1
 * @param pageSize      页面可显示行数
 * @param sort
 * @return
 */
public static Page getPage(JpaRepository repository, int currentPageNo, int pageSize, Sort sort) {
    //jpa 中起始页为 0，但传递过来的参数 currentPageNo 不能小于1
    Assert.isTrue(currentPageNo >= 1, "currentPageNo  需要 >= 1 ");
    currentPageNo = currentPageNo - 1;
    return repository.findAll(new PageRequest(currentPageNo, pageSize, sort));
}
 

public abstract JpaRepository<T,ID> repository(); 

protected abstract JpaRepository getRepository();