org.springframework.data.jpa.repository.support.JpaEntityInformation Java Examples

@Override
@SuppressWarnings({ "unchecked", "rawtypes" })
protected <T, ID extends Serializable> SimpleJpaRepository<?, ?> getTargetRepository(
        final RepositoryMetadata metadata, final EntityManager entityManager) {

    Class<?> repositoryInterface = metadata.getRepositoryInterface();

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

    if (isQueryDslExecutor(repositoryInterface)) {
        return new QueryDslJpaRepository(entityInformation, entityManager);
    } else {
        return new GenericRepositoryImpl(entityInformation, entityManager, namedQueryUtil); // custom
    }
}
 

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;
}
 

protected Object getTargetRepository(RepositoryMetadata metadata) {
    Class<?> repositoryInterface = metadata.getRepositoryInterface();

    if (isBaseRepository(repositoryInterface)) {

        JpaEntityInformation<M, ID> entityInformation = getEntityInformation((Class<M>) metadata.getDomainType());
        SimpleBaseRepository repository = new SimpleBaseRepository<M, ID>(entityInformation, entityManager);

        SearchableQuery searchableQuery = AnnotationUtils.findAnnotation(repositoryInterface, SearchableQuery.class);
        if (searchableQuery != null) {
            String countAllQL = searchableQuery.countAllQuery();
            if (!StringUtils.isEmpty(countAllQL)) {
                repository.setCountAllQL(countAllQL);
            }
            String findAllQL = searchableQuery.findAllQuery();
            if (!StringUtils.isEmpty(findAllQL)) {
                repository.setFindAllQL(findAllQL);
            }
            Class<? extends SearchCallback> callbackClass = searchableQuery.callbackClass();
            if (callbackClass != null && callbackClass != SearchCallback.class) {
                repository.setSearchCallback(BeanUtils.instantiate(callbackClass));
            }

            repository.setJoins(searchableQuery.joins());

        }

        return repository;
    }
    return super.getTargetRepository(metadata);
}
 

@Override
protected JpaRepositoryImplementation<?, ?> getTargetRepository(RepositoryInformation information, EntityManager entityManager) {
    JpaEntityInformation<?, Serializable> entityInformation = this.getEntityInformation(information.getDomainType());
    Object repository = this.getTargetRepositoryViaReflection(information, new Object[]{entityInformation, entityManager});
    Assert.isInstanceOf(BaseRepositoryImpl.class, repository);
    return (JpaRepositoryImplementation)repository;
}
 

public SimpleBaseRepository(JpaEntityInformation<M, ID> entityInformation, EntityManager entityManager) {
    super(entityInformation, entityManager);

    this.entityInformation = entityInformation;
    this.entityClass = this.entityInformation.getJavaType();
    this.entityName = this.entityInformation.getEntityName();
    this.idName = this.entityInformation.getIdAttributeNames().iterator().next();
    this.em = entityManager;

    repositoryHelper = new RepositoryHelper(entityClass);

    findAllQL = String.format(FIND_QUERY_STRING, entityName);
    countAllQL = String.format(COUNT_QUERY_STRING, entityName);
}
 

@Override
protected JpaRepositoryImplementation<?, ?> getTargetRepository(RepositoryInformation information, EntityManager entityManager) {
    JpaEntityInformation<?, Serializable> entityInformation = this.getEntityInformation(information.getDomainType());
    Object repository = this.getTargetRepositoryViaReflection(information, new Object[]{entityInformation, entityManager});
    Assert.isInstanceOf(BaseRepositoryImpl.class, repository);
    return (JpaRepositoryImplementation)repository;
}
 

public EntityGraphQuerydslRepository(
    JpaEntityInformation<T, ID> entityInformation,
    EntityManager entityManager,
    EntityPathResolver resolver) {
  super(entityInformation, entityManager);
  this.querydslJpaRepositoryDelegate =
      new EntityGraphAwareQuerydslJpaRepository<>(entityInformation, entityManager, resolver);
}
 

@SuppressWarnings("unchecked")
public EntityGraphQuerydslRepository(
    JpaEntityInformation<T, ?> entityInformation, EntityManager entityManager) {
  super(entityInformation, entityManager);
  this.querydslJpaRepositoryDelegate =
      new EntityGraphAwareQuerydslJpaRepository<>(
          (JpaEntityInformation<T, ID>) entityInformation, entityManager);
}
 

public GenericJpaRepositoryImpl(JpaEntityInformation<T, ID> eif, EntityManager em) {
    super(eif, em);
    this.eif = eif;
    PropertyDescriptor descriptor = findFieldPropertyDescriptor(eif.getJavaType(), Status.class);
    isStatusAble = descriptor != null;
    if (isStatusAble) {
        statusReadMethod = descriptor.getReadMethod();
        statusWriteMethod = descriptor.getWriteMethod();
    }
}
 

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;
}
 

@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);
}
 

/**
 * Creates a new {@link SimpleJpaRepository} to manage objects of the given
 * {@link JpaEntityInformation}.
 */
public GenericRepositoryImpl(final JpaEntityInformation<T, ?> entityInformation, final EntityManager entityManager,
        final NamedQueryUtil namedQueryUtil) {
    super(entityInformation, entityManager);
    this.entityInformation = entityInformation;
    this.em = entityManager;
    // provider =
    // DefaultPersistenceProvider.fromEntityManager(entityManager);
    // this.springDataRepositoryInterface = springDataRepositoryInterface;
    this.namedQueryUtil = namedQueryUtil;
    this.byExampleSpecification = new ByExampleSpecification(entityManager);
}
 

@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)));
}
 

public EntityGraphQuerydslRepositoryChild(
    JpaEntityInformation<Object, ?> entityInformation, EntityManager entityManager) {
  super(entityInformation, entityManager);
}
 

public DefaultPlatformJpaRepository(JpaEntityInformation<T, ?> entityInformation, EntityManager entityManager) {
    super(entityInformation, entityManager);
    this.entityManager = entityManager;
}
 

public EntityGraphSimpleJpaRepository(
    JpaEntityInformation<T, ?> entityInformation, EntityManager entityManager) {
  super(entityInformation, entityManager);
}
 

public EntityGraphAwareQuerydslJpaRepository(
    JpaEntityInformation<T, ID> entityInformation,
    EntityManager entityManager,
    EntityPathResolver resolver) {
  super(entityInformation, entityManager, resolver);
}
 

public EntityGraphAwareQuerydslJpaRepository(
    JpaEntityInformation<T, ID> entityInformation, EntityManager entityManager) {
  super(entityInformation, entityManager);
}
 

@Override
protected DefaultPlatformJpaRepository getTargetRepository(RepositoryInformation information) {
    JpaEntityInformation<?, Serializable> entityInformation = getEntityInformation(information.getDomainType());
    return new DefaultPlatformJpaRepository(entityInformation, em);
}
 

public JpaEntityInformation<T, ?> getEntityInformation() {
	return entityInformation;
}
 

/** 指定したエンティティの ID 値を取得します。 */
@SuppressWarnings("unchecked")
public <T> Serializable idValue(T entity) {
    return ((JpaEntityInformation<T, Serializable>)OrmUtils.entityInformation(em, entity.getClass())).getId(entity);
}
 

public CustomSimpleJpaRepository(JpaEntityInformation<T, ?> entityInformation, EntityManager entityManager) {
	super(entityInformation, entityManager);
}
 

QDataTablesRepositoryImpl(JpaEntityInformation<T, ID> entityInformation,
    EntityManager entityManager) {
  this(entityInformation, entityManager, DEFAULT_ENTITY_PATH_RESOLVER);
}
 

public QDataTablesRepositoryImpl(JpaEntityInformation<T, ID> entityInformation,
    EntityManager entityManager, EntityPathResolver resolver) {
  super(entityInformation, entityManager);
  EntityPath<T> path = resolver.createPath(entityInformation.getJavaType());
  this.builder = new PathBuilder<>(path.getType(), path.getMetadata());
}
 

DataTablesRepositoryImpl(JpaEntityInformation<T, ?> entityInformation,
    EntityManager entityManager) {

  super(entityInformation, entityManager);
}
 

public JooqJpaRepository(JpaEntityInformation<T, ?> entityInformation, EntityManager entityManager, DSLContext jooq) {
	super(entityInformation, entityManager);
	this.entityInformation = entityInformation;
	this.jooq = jooq;
}
 

public ExtendedRepositoryImpl(JpaEntityInformation<T, ?> entityInformation, EntityManager entityManager) {
    super(entityInformation, entityManager);
    this.entityManager = entityManager;
}
 

public <T> JpaEntityInformation<T, ?> getMetadata(Class<T> entityClass) {
    return JpaEntityInformationSupport.getMetadata(entityClass, entityManager);
}
 

public GenericRepositoryImpl(JpaEntityInformation<T, Serializable> entityInformation, EntityManager entityManager) {
  super(entityInformation, entityManager);
  this.entityInformation = entityInformation;
  this.entityManager = entityManager;
}
 

public JpaSupportRepository(JpaEntityInformation<T, ?> entityInformation, EntityManager em) {
	super(entityInformation, em);
	this.entityInformation = entityInformation;
	this.entityManager = em;
}