Java JpaEntityInformation類代碼示例

import org.springframework.data.jpa.repository.support.JpaEntityInformation; //導入依賴的package包/類
@Override
@SuppressWarnings({"unchecked", "rawtypes"})
protected SimpleJpaRepository<?, ?> getTargetRepository(
        final RepositoryMetadata metadata,
        final EntityManager entityManager) {
    final Class<?> repositoryInterface = metadata.getRepositoryInterface();
    final JpaEntityInformation<?, Serializable> entityInformation = getEntityInformation(metadata.getDomainType());

    if (isQueryDslSpecificExecutor(repositoryInterface)) {
        throw new IllegalArgumentException("QueryDSL interface niet toegestaan");
    }

    return isMaxedRepository(repositoryInterface)
            ? new CustomSimpleMaxedJpaRepository(entityInformation, entityManager)
            : isQuerycostRepository(repositoryInterface)
                    ? new CustomSimpleQuerycostJpaRepository(entityInformation, entityManager, maxCostsQueryPlan)
                    : new CustomSimpleJpaRepository(entityInformation, entityManager);
}
 

import org.springframework.data.jpa.repository.support.JpaEntityInformation; //導入依賴的package包/類
protected SimpleJpaRepository<?, ?> getTargetRepository(RepositoryInformation information,
    EntityManager entityManager) {
  Class<?> domainType = information.getDomainType();
  if (!hasAclStrategyAnnotation(domainType)) {
    return super.getTargetRepository(information, entityManager);
  }

  JpaEntityInformation<?, Serializable> entityInformation = getEntityInformation(domainType);

  // invokes
  // com.github.lothar.security.acl.jpa.repository.AclJpaRepository.AclJpaRepository(JpaEntityInformation<T,
  // ?>, EntityManager, JpaSpecProvider<T>)
  SimpleJpaRepository<?, ?> repository = getTargetRepositoryViaReflection(information,
      entityInformation, entityManager, jpaSpecProvider);
  logger.debug("Created {}", repository);

  return repository;
}
 

import org.springframework.data.jpa.repository.support.JpaEntityInformation; //導入依賴的package包/類
@Override
protected <T, ID extends Serializable> JpaRepository<?, ?> getTargetRepository(
		RepositoryMetadata metadata, EntityManager entityManager) {

	JpaEntityInformation<?, Serializable> entityInformation = getEntityInformation(metadata
			.getDomainType());
	return new GenericRepositoryImpl(entityInformation, entityManager); // custom
																		// implementation
}
 

import org.springframework.data.jpa.repository.support.JpaEntityInformation; //導入依賴的package包/類
@SuppressWarnings({ "rawtypes", "unchecked" })
@Override
protected <T, ID extends Serializable> SimpleJpaRepository<?, ?> getTargetRepository(
		RepositoryInformation information, EntityManager entityManager) {
	JpaEntityInformation<?, Serializable> entityInformation = getEntityInformation(information.getDomainType());
	return new GenericRepositoryImpl(entityInformation, entityManager);
}
 

import org.springframework.data.jpa.repository.support.JpaEntityInformation; //導入依賴的package包/類
@Test
public void repositoriesAreAssignedToAppropriateStores() {

	Repositories repositories = new Repositories(context);

	assertThat(repositories.getEntityInformationFor(Customer.class), is(instanceOf(JpaEntityInformation.class)));
	assertThat(repositories.getEntityInformationFor(Order.class), is(instanceOf(MongoEntityInformation.class)));
}
 

import org.springframework.data.jpa.repository.support.JpaEntityInformation; //導入依賴的package包/類
SimpleExtendedQueryDslJpaRepository(JpaEntityInformation<T, ID> entityInformation,
                                    EntityManager entityManager) throws SQLException {
    super(entityInformation, entityManager, SimpleEntityPathResolver.INSTANCE);
    this.jpaQueryFactory = new JPAQueryFactory(HQLTemplates.DEFAULT, entityManager);
    this.path = SimpleEntityPathResolver.INSTANCE.createPath(entityInformation.getJavaType());
    SQLTemplates sqlTemplates = getSQLServerTemplates(entityManager.getEntityManagerFactory());
    this.jpaSqlFactory = () -> new JPASQLQuery<>(entityManager, sqlTemplates);
    this.entityManager = entityManager;
}
 

import org.springframework.data.jpa.repository.support.JpaEntityInformation; //導入依賴的package包/類
@Before
public void setup(){
    JpaEntityInformation<TestEntity, Integer> information = new JpaMetamodelEntityInformation<>(
            TestEntity.class, em.getMetamodel());
    repository = new SimpleJpaRepository<>(information, em);
    entities = SpecificationBuilder.selectDistinctFrom(repository).where(new Filter("string",EQUAL,"a")).findAll();
    Assert.assertTrue(entities.size() >= 1);
}
 

import org.springframework.data.jpa.repository.support.JpaEntityInformation; //導入依賴的package包/類
/**
 * Creates a new {@link CustomSimpleMaxedJpaRepository} to manage objects of the given {@link JpaEntityInformation}.
 * @param entityInformation must not be {@literal null}.
 * @param entityManager must not be {@literal null}.
 * @param maximumRecords maximum aantal records
 */
public CustomSimpleMaxedJpaRepository(
        final JpaEntityInformation<T, ?> entityInformation,
        final EntityManager entityManager,
        final int maximumRecords) {
    super(entityInformation, entityManager);
    em = entityManager;
    this.maximumRecords = maximumRecords;
}
 

import org.springframework.data.jpa.repository.support.JpaEntityInformation; //導入依賴的package包/類
/**
 * Creates a new {@link CustomSimpleQuerycostJpaRepository} to manage objects of the given {@link JpaEntityInformation}.
 * @param entityInformation must not be {@literal null}.
 * @param entityManager must not be {@literal null}.
 * @param maxCostsQueryPlan maximum cost of a query plan
 */
CustomSimpleQuerycostJpaRepository(
        final JpaEntityInformation<T, ?> entityInformation,
        final EntityManager entityManager,
        final int maxCostsQueryPlan) {
    super(entityInformation, entityManager);
    this.em = entityManager;
    this.maxCostsQueryPlan = maxCostsQueryPlan;
}
 

import org.springframework.data.jpa.repository.support.JpaEntityInformation; //導入依賴的package包/類
@Override
public void setApplicationContext(ApplicationContext context) throws BeansException {
    Class<?>[] classes = GenericTypeResolver.resolveTypeArguments(this.getClass(), RepoBasedConverter.class);
    Class<?> clazz = classes[0];
    this.repositories = new Repositories(context);
    this.entityInformation = (JpaEntityInformation<S, ID>) repositories.getEntityInformationFor(clazz);
    this.genericJpaRepository = (GenericJpaRepository<S, ID>) repositories.getRepositoryFor(clazz);
    this.useCache = genericJpaRepository instanceof CachingJpaRepository;
}
 

import org.springframework.data.jpa.repository.support.JpaEntityInformation; //導入依賴的package包/類
public GenericJpaRepositoryImpl(JpaEntityInformation<T, ID> eif, EntityManager em) {
	super(eif, em);
	this.em = em;
	this.eif = eif;
	PropertyDescriptor descriptor = findFieldPropertyDescriptor(eif.getJavaType(), Status.class);
	isStatusAble = descriptor != null;
	if (isStatusAble) {
		statusReadMethod = descriptor.getReadMethod();
		statusWriteMethod = descriptor.getWriteMethod();
	}
}
 

import org.springframework.data.jpa.repository.support.JpaEntityInformation; //導入依賴的package包/類
public EntityGraphQuerydslRepository(
    JpaEntityInformation<T, ?> entityInformation, EntityManager entityManager) {
  super(entityInformation, entityManager);
  this.querydslJpaRepositoryDelegate =
      new EntityGraphAwareQuerydslJpaRepository<>(
          (JpaEntityInformation<T, ID>) entityInformation, entityManager);
}
 

import org.springframework.data.jpa.repository.support.JpaEntityInformation; //導入依賴的package包/類
@SuppressWarnings({ "unchecked" })
protected Object getTargetRepository(RepositoryMetadata metadata) {
	JpaEntityInformation<T, Serializable> entityInformation = (JpaEntityInformation<T, Serializable>) getEntityInformation(metadata
			.getDomainType());
	return new CalendarDTRepositoryImpl<T, ID>(entityInformation,
			entityManager);
}
 

import org.springframework.data.jpa.repository.support.JpaEntityInformation; //導入依賴的package包/類
public CentromereJpaRepository(JpaEntityInformation<T, ID> entityInformation,
		EntityManager entityManager) {
	super(entityInformation, entityManager);
	this.metadata = entityInformation;
	this.entityManager = entityManager;
	this.queryBuilder = new JpaQueryBuilder<>(entityManager);
}
 

import org.springframework.data.jpa.repository.support.JpaEntityInformation; //導入依賴的package包/類
private JpaRepository(JpaEntityInformation<T, ID> info, EntityManager em) {
	//this.entityClass = info.getJavaType();
	this.entityInformation = info;
	this.entityManager = em;
	
	this.template = new SimpleJpaRepository<T, ID>(info, em);
	this.queryDslExecutor = new JpaQueryDslExecutor<T>(info.getJavaType(), em);
}