import org.springframework.data.repository.support.Repositories; //导入依赖的package包/类
public static Object save(Repositories repositories, Object domainObj) 
		throws HttpRequestMethodNotSupportedException {

	RepositoryInformation ri = findRepositoryInformation(repositories, domainObj.getClass());

	if (ri == null) {
		throw new ResourceNotFoundException();
	}

	Class<?> domainObjClazz = ri.getDomainType();
	
	if (domainObjClazz != null) {
		Method saveMethod = ri.getCrudMethods().getSaveMethod();
		if (saveMethod == null) {
			throw new HttpRequestMethodNotSupportedException("save");
		}
		domainObj = ReflectionUtils.invokeMethod(saveMethod, repositories.getRepositoryFor(domainObjClazz), domainObj);
	}

	return domainObj;
}
 

import org.springframework.data.repository.support.Repositories; //导入依赖的package包/类
public static Repositories setUpRepositoryProviderMock(Map<Class<?>, Repository<?, ?>> repositoriesMap)
{
	Repositories mockRepositories = Mockito.mock(Repositories.class);
	when(mockRepositories.getRepositoryFor(any())).thenAnswer(new Answer<Object>() {
		@Override
		public Object answer(InvocationOnMock invocation) throws Throwable
		{
			Class<?> entityClass = (Class<?>) invocation.getArguments()[0];
			Repository<?, ?> repository = repositoriesMap.get(entityClass);
			if (repository == null)
			{
				throw new IllegalArgumentException("Unsupported class: " + entityClass.getName());
			}
			return repository;
		}
	});
	RepositoryProvider.setRepositories(mockRepositories);
	return mockRepositories;
}
 

import org.springframework.data.repository.support.Repositories; //导入依赖的package包/类
@SuppressWarnings(value = "unchecked")
public CrudRepository<Object, Serializable> find(@NotNull Class<?> domainClass) {
    Repositories repositories = new Repositories(listableBeanFactory);

    Iterator<Class<?>> it = repositories.iterator();
    while (it.hasNext()) {
        Object repository = repositories.getRepositoryFor(domainClass);
        if (repository != null && repository instanceof CrudRepository) {
            return (CrudRepository<Object, Serializable>)repository;
        }
    }

    return null;
}
 

import org.springframework.data.repository.support.Repositories; //导入依赖的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.repository.support.Repositories; //导入依赖的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.repository.support.Repositories; //导入依赖的package包/类
@Autowired 
public ContentSearchRestController(Repositories repositories, ContentStoreService stores, PagedResourcesAssembler<Object> assembler) {
	super(assembler);
	
	this.repositories = repositories;
	this.stores = stores;
	this.reflectionService = new ReflectionServiceImpl();
}
 

import org.springframework.data.repository.support.Repositories; //导入依赖的package包/类
@Autowired(required=false)
public ContentPropertyCollectionRestController(ApplicationContext context, ContentStoreService stores, StoreByteRangeHttpRequestHandler handler) {
	super();
	try {
		this.repositories = context.getBean(Repositories.class);
	} catch (BeansException be) {
		this.repositories = new Repositories(context);
	}
	this.storeService = stores;
	this.handler = handler;
}
 

import org.springframework.data.repository.support.Repositories; //导入依赖的package包/类
@Autowired 
public ContentEntityRestController(ApplicationContext context, ContentStoreService storeService, StoreByteRangeHttpRequestHandler handler) {
	try {
		this.repositories = context.getBean(Repositories.class);
	} catch (BeansException be) {
		this.repositories = new Repositories(context);
	}
	this.storeService = storeService;
	this.handler = handler;
}
 

import org.springframework.data.repository.support.Repositories; //导入依赖的package包/类
public static Object findOne(Repositories repositories, String repository, String id) 
		throws HttpRequestMethodNotSupportedException {
	
	Object domainObj = null;
	
	RepositoryInformation ri = findRepositoryInformation(repositories, repository);

	if (ri == null) {
		throw new ResourceNotFoundException();
	}
	
	Class<?> domainObjClazz = ri.getDomainType();
	Class<?> idClazz = ri.getIdType();
	
	Method findOneMethod = ri.getCrudMethods().getFindOneMethod();
	if (findOneMethod == null) {
		throw new HttpRequestMethodNotSupportedException("fineOne");
	}
	
	Object oid = new DefaultConversionService().convert(id, idClazz);
	domainObj = ReflectionUtils.invokeMethod(findOneMethod, repositories.getRepositoryFor(domainObjClazz), oid);
	
	if (null == domainObj) {
		throw new ResourceNotFoundException();
	}
	
	return domainObj;
}
 

import org.springframework.data.repository.support.Repositories; //导入依赖的package包/类
public static Iterable findAll(Repositories repositories, String repository) 
		throws HttpRequestMethodNotSupportedException {
	
	Iterable entities = null;
	
	RepositoryInformation ri = findRepositoryInformation(repositories, repository);

	if (ri == null) {
		throw new ResourceNotFoundException();
	}
	
	Class<?> domainObjClazz = ri.getDomainType();
	Class<?> idClazz = ri.getIdType();
	
	Method findAllMethod = ri.getCrudMethods().getFindAllMethod();
	if (findAllMethod == null) {
		throw new HttpRequestMethodNotSupportedException("fineAll");
	}
	
	entities = (Iterable)ReflectionUtils.invokeMethod(findAllMethod, repositories.getRepositoryFor(domainObjClazz));
	
	if (null == entities) {
		throw new ResourceNotFoundException();
	}
	
	return entities;
}
 

import org.springframework.data.repository.support.Repositories; //导入依赖的package包/类
public static RepositoryInformation findRepositoryInformation(Repositories repositories, String repository) {
	RepositoryInformation ri = null;
	for (Class<?> clazz : repositories) {
		RepositoryInformation candidate = repositories.getRepositoryInformationFor(clazz);
		if (candidate == null) {
			continue;
		}
		if (repository.equals(RepositoryUtils.repositoryPath(candidate))) {
			ri = repositories.getRepositoryInformationFor(clazz);
			break;
		}
	}
	return ri;
}
 

import org.springframework.data.repository.support.Repositories; //导入依赖的package包/类
@Autowired(required=false)
public ContentPropertyRestController(ApplicationContext context, ContentStoreService storeService, StoreByteRangeHttpRequestHandler handler) {
	super();
	try {
		this.repositories = context.getBean(Repositories.class);
	} catch (BeansException be) {
		this.repositories = new Repositories(context);
	}
	this.storeService = storeService;
	this.handler = handler;
}
 

import org.springframework.data.repository.support.Repositories; //导入依赖的package包/类
private void replaceContentInternal(Repositories repositories,
									ContentStoreService stores,
									String repository,
									String id, 
									String contentProperty, 
									String contentId, 
									String mimeType,
									InputStream stream) 
		throws HttpRequestMethodNotSupportedException {

	Object domainObj = findOne(repositories, repository, id);

	PersistentProperty<?> property = this.getContentPropertyDefinition(repositories.getPersistentEntity(domainObj.getClass()), contentProperty);
	
	Object contentPropertyValue = this.getContentProperty(domainObj, property, contentId); 
	
	if (BeanUtils.hasFieldWithAnnotation(contentPropertyValue, MimeType.class)) {
		BeanUtils.setFieldWithAnnotation(contentPropertyValue, MimeType.class, mimeType);
	}
	
	Class<?> contentEntityClass = ContentPropertyUtils.getContentPropertyType(property);
	
	ContentStoreInfo info = ContentStoreUtils.findContentStore(storeService, contentEntityClass);
	info.getImpementation().setContent(contentPropertyValue, stream);
	
	save(repositories, domainObj);
}
 

import org.springframework.data.repository.support.Repositories; //导入依赖的package包/类
@Autowired
public ApplicationStructureController(ApplicationStructureBuilder applicationStructureBuilder, RepositoryRestConfiguration configuration, Repositories repositories, ResourceMappings mappings) {
    Assert.notNull(applicationStructureBuilder, "ApplicationStructureBuilder must not be null!");
    Assert.notNull(configuration, "RepositoryRestConfiguration must not be null!");
    Assert.notNull(repositories, "Repositories must not be null!");
    Assert.notNull(mappings, "ResourceMappings must not be null!");

    this.applicationStructureBuilder = applicationStructureBuilder;
    this.configuration = configuration;
    this.repositories = repositories;
    this.mappings = mappings;
}
 

import org.springframework.data.repository.support.Repositories; //导入依赖的package包/类
public static PersistentEntity<?,?> findPersistentEntity(Repositories repositories, 
												  Class<?> domainType) {

	PersistentEntity<?, ?> persistentEntity = repositories.getPersistentEntity(domainType);
	return persistentEntity;
}
 

import org.springframework.data.repository.support.Repositories; //导入依赖的package包/类
@PostConstruct
public void init() {
    repositories = new Repositories(applicationContext);
    repositoryInvokerFactory = new DefaultRepositoryInvokerFactory(repositories, conversionService);
}
 

import org.springframework.data.repository.support.Repositories; //导入依赖的package包/类
@PostConstruct
public void init() {
    repositories = new Repositories(context);
}
 

import org.springframework.data.repository.support.Repositories; //导入依赖的package包/类
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException
{
	repositories = new Repositories(applicationContext);
}
 

import org.springframework.data.repository.support.Repositories; //导入依赖的package包/类
public static void setRepositories(Repositories repositories)
{
	RepositoryProvider.repositories = repositories;
}
 

import org.springframework.data.repository.support.Repositories; //导入依赖的package包/类
public DemoRepositoryEntityLinks(Repositories repositories,
		ResourceMappings mappings, RepositoryRestConfiguration config, HateoasPageableHandlerMethodArgumentResolver resolver,org.springframework.plugin.core.PluginRegistry<BackendIdConverter,Class<?>> idConverters) {
	super(repositories, mappings, config, resolver,idConverters);
	this.resourceMappings = mappings;
	this.config = config;
}