/*
* (non-Javadoc)
* @see org.springframework.data.rest.core.mapping.ResourceMappings#getSearchResourceMappings(java.lang.Class)
*/
@Override
public SearchResourceMappings getSearchResourceMappings(Class<?> domainType) {
Assert.notNull(domainType, "Type must not be null!");
if (searchCache.containsKey(domainType)) {
return searchCache.get(domainType);
}
RepositoryInformation repositoryInformation =
repositories.getRepositoryInformationFor(domainType);
List<MethodResourceMapping> mappings = new ArrayList<MethodResourceMapping>();
ResourceMetadata resourceMapping = getMetadataFor(domainType);
if (resourceMapping.isExported()) {
for (Method queryMethod : repositoryInformation.getQueryMethods()) {
RepositoryMethodResourceMapping methodMapping =
new RepositoryMethodResourceMapping(
queryMethod, resourceMapping, repositoryInformation);
if (methodMapping.isExported()) {
mappings.add(methodMapping);
}
}
}
SearchResourceMappings searchResourceMappings = new SearchResourceMappings(mappings);
searchCache.put(domainType, searchResourceMappings);
return searchResourceMappings;
}
protected void populateJpaClasses() {
if (repositoryInformations == null) {
repositoryInformations = new ArrayList<RepositoryInformation>();
}
for (Class<?> clazz : repositories) {
RepositoryInformation repoInfo = repositories.getRepositoryInformationFor(clazz);
if (includeClasses != null) {
if (includeClasses.contains(repoInfo.getDomainType())) {
repositoryInformations.add(repoInfo);
}
} else if (excludeClasses != null) {
if (!excludeClasses.contains(repoInfo.getDomainType())) {
repositoryInformations.add(repoInfo);
}
} else {
repositoryInformations.add(repoInfo);
}
}
}
private final void populateCache(
Repositories repositories, RelProvider provider, RepositoryDetectionStrategy strategy) {
for (Class<?> type : repositories) {
RepositoryInformation repositoryInformation = repositories.getRepositoryInformationFor(type);
Class<?> repositoryInterface = repositoryInformation.getRepositoryInterface();
PersistentEntity<?, ?> entity = repositories.getPersistentEntity(type);
CollectionResourceMapping mapping =
new RepositoryCollectionResourceMapping(repositoryInformation, provider, strategy);
RepositoryAwareResourceMetadata information =
new RepositoryAwareResourceMetadata(entity, mapping, this, repositoryInformation);
addToCache(repositoryInterface, information);
if (!hasMetadataFor(type) || information.isPrimary()) {
addToCache(type, information);
}
}
}
private final void populateCache(Repositories repositories) {
for (Class<?> type : repositories) {
RepositoryInformation repositoryInformation = repositories.getRepositoryInformationFor(type);
Class<?> repositoryInterface = repositoryInformation.getRepositoryInterface();
CollectionResourceMapping mapping =
new RepositoryCollectionResourceMapping(repositoryInterface, relProvider);
RepositoryAwareResourceInformation information =
new RepositoryAwareResourceInformation(
repositories, mapping, this, repositoryInformation);
cache.put(repositoryInterface, information);
if (!cache.containsKey(type) || information.isPrimary()) {
cache.put(type, information);
}
}
}
/**
* Creates the {@link Descriptor}s for pagination parameters.
*
* @param type
* @return
*/
private List<Descriptor> getPaginationDescriptors(Class<?> type, HttpMethod method) {
RepositoryInformation information = repositories.getRepositoryInformationFor(type);
if (!information.isPagingRepository() || !getType(method).equals(Type.SAFE)) {
return Collections.emptyList();
}
Link linkToCollectionResource = entityLinks.linkToCollectionResource(type);
List<TemplateVariable> variables = linkToCollectionResource.getVariables();
List<Descriptor> descriptors = new ArrayList<Descriptor>(variables.size());
ProjectionDefinitionConfiguration projectionConfiguration =
configuration.projectionConfiguration();
for (TemplateVariable variable : variables) {
// Skip projection parameter
if (projectionConfiguration.getParameterName().equals(variable.getName())) {
continue;
}
ResourceDescription description =
SimpleResourceDescription.defaultFor(variable.getDescription());
descriptors.add( //
descriptor()
. //
name(variable.getName())
. //
type(Type.SEMANTIC)
. //
doc(getDocFor(description))
. //
build());
}
return descriptors;
}
/**
* Same signature as {@link #getTransactionAttribute}, but doesn't cache the result. {@link
* #getTransactionAttribute} is effectively a caching decorator for this method.
*
* @see #getTransactionAttribute
*/
private TransactionAttribute computeTransactionAttribute(Method method, Class<?> targetClass) {
// Don't allow no-public methods as required.
if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {
return null;
}
// Ignore CGLIB subclasses - introspect the actual user class.
Class<?> userClass = ClassUtils.getUserClass(targetClass);
// The method may be on an interface, but we need attributes from the target class.
// If the target class is null, the method will be unchanged.
Method specificMethod = ClassUtils.getMostSpecificMethod(method, userClass);
// If we are dealing with method with generic parameters, find the original method.
specificMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);
TransactionAttribute txAtt = null;
if (specificMethod != method) {
// Fallback is to look at the original method.
txAtt = findTransactionAttribute(method);
if (txAtt != null) {
return txAtt;
}
// Last fallback is the class of the original method.
txAtt = findTransactionAttribute(method.getDeclaringClass());
if (txAtt != null || !enableDefaultTransactions) {
return txAtt;
}
}
// Start: Implementation class check block
// First try is the method in the target class.
txAtt = findTransactionAttribute(specificMethod);
if (txAtt != null) {
return txAtt;
}
// Second try is the transaction attribute on the target class.
txAtt = findTransactionAttribute(specificMethod.getDeclaringClass());
if (txAtt != null) {
return txAtt;
}
if (!enableDefaultTransactions) {
return null;
}
// Fallback to implementation class transaction settings of nothing found
// return findTransactionAttribute(method);
Method targetClassMethod = repositoryInformation.getTargetClassMethod(method);
if (targetClassMethod.equals(method)) {
return null;
}
txAtt = findTransactionAttribute(targetClassMethod);
if (txAtt != null) {
return txAtt;
}
txAtt = findTransactionAttribute(targetClassMethod.getDeclaringClass());
if (txAtt != null) {
return txAtt;
}
return null;
// End: Implementation class check block
}
