Spring Data之Repository创建及源码分析

其他 2018-11-30 02:33:03 阅读次数: 0

背景

在上一篇文章Spring Data之EntityManager创建及源码分析介绍了EntityManager的创建过程，我们使用Spring Data JPA开发时一般是通过自定义一个例如UserRepository的接口，然后继承JpaRepository或者CrudRepository、PagingAndSortingRepository从而获得一系列默认的CURD方法。

public interface UserRepository extends JpaRepository<User,Long> {
}

@Autowired
private UserRepository userRepository;
    
public void queryAll() {
    List<User> users = userRepository.findAll();
    log.info("result：{}",users);
}

我们知道接口是不能被实例化的，但通过@Autowired private UserRepository userRepository就能使用userRepository实例的方法进行持久化操作。UserRepository接口是在什么时候被谁实现的呢，跟EntityManager又是如何结合在一起的呢？@Autowired注入的对象又是谁呢？这篇文章就来进行分析。

Repository创建

通过上一篇文章我们知道，Repository的配置是通过RepositoryConfigurationDelegate类组装实现的，这里面就包含了寻找Repository接口的子类（这里其实是子接口），并将其通过BeanDefinitionBuilder创建一个Bean实例注册到Bean Factory中，该Bean实例就是UserRepository的真实实现了。

RepositoryConfigurationDelegate

下面我们先看RepositoryConfigurationDelegate的registerRepositoriesIn方法

public List<BeanComponentDefinition> registerRepositoriesIn(BeanDefinitionRegistry registry,
		RepositoryConfigurationExtension extension) {

	extension.registerBeansForRoot(registry, configurationSource);

	RepositoryBeanDefinitionBuilder builder = new RepositoryBeanDefinitionBuilder(registry, extension, resourceLoader,
			environment);
	List<BeanComponentDefinition> definitions = new ArrayList<>();

	//获取RepositoryConfiguration的集合
	for (RepositoryConfiguration<? extends RepositoryConfigurationSource> configuration : extension
			.getRepositoryConfigurations(configurationSource, resourceLoader, inMultiStoreMode)) {

		//将configuration转换为BeanDefinitionBuilder
		BeanDefinitionBuilder definitionBuilder = builder.build(configuration);

		//给definitionBuilder指定若干属性的赋值，包含entityManager
		extension.postProcess(definitionBuilder, configurationSource);

		if (isXml) {
			extension.postProcess(definitionBuilder, (XmlRepositoryConfigurationSource) configurationSource);
		} else {
			extension.postProcess(definitionBuilder, (AnnotationRepositoryConfigurationSource) configurationSource);
		}

		AbstractBeanDefinition beanDefinition = definitionBuilder.getBeanDefinition();
		//获取注册Bean的名称，也就是UserRepository接口实际对象的Bean名称
		String beanName = configurationSource.generateBeanName(beanDefinition);

		if (LOGGER.isDebugEnabled()) {
			LOGGER.debug(REPOSITORY_REGISTRATION, extension.getModuleName(), beanName,
					configuration.getRepositoryInterface(), configuration.getRepositoryFactoryBeanClassName());
		}

		beanDefinition.setAttribute(FACTORY_BEAN_OBJECT_TYPE, configuration.getRepositoryInterface());

		//注册定义好的Bean，即在Application Context中创建该Bean的实例
		registry.registerBeanDefinition(beanName, beanDefinition);
		definitions.add(new BeanComponentDefinition(beanDefinition, beanName));
	}

	return definitions;
}

其中for里面的extension.getRepositoryConfigurations是关键，该方法就是寻找UserRepository的地方，具体实现如下

public abstract class RepositoryConfigurationExtensionSupport implements RepositoryConfigurationExtension {
	
	public <T extends RepositoryConfigurationSource> Collection<RepositoryConfiguration<T>> getRepositoryConfigurations(
			T configSource, ResourceLoader loader, boolean strictMatchesOnly) {

		Assert.notNull(configSource, "ConfigSource must not be null!");
		Assert.notNull(loader, "Loader must not be null!");

		Set<RepositoryConfiguration<T>> result = new HashSet<>();

		//获取Repository接口子类的Bean定义
		for (BeanDefinition candidate : configSource.getCandidates(loader)) {

			RepositoryConfiguration<T> configuration = getRepositoryConfiguration(candidate, configSource);
			Class<?> repositoryInterface = loadRepositoryInterface(configuration,
					getConfigurationInspectionClassLoader(loader));

			if (repositoryInterface == null) {
				result.add(configuration);
				continue;
			}

			RepositoryMetadata metadata = AbstractRepositoryMetadata.getMetadata(repositoryInterface);

			if (!useRepositoryConfiguration(metadata)) {
				continue;
			}

			if (!strictMatchesOnly || configSource.usesExplicitFilters()) {
				result.add(configuration);
				continue;
			}

			if (isStrictRepositoryCandidate(metadata)) {
				result.add(configuration);
			}
		}

		return result;
	}
}

getCandidates的实现

public abstract class RepositoryConfigurationSourceSupport implements RepositoryConfigurationSource {
	@Override
	public Streamable<BeanDefinition> getCandidates(ResourceLoader loader) {

		//定义了一个scanner指定需要包含的类型
		RepositoryComponentProvider scanner = new RepositoryComponentProvider(getIncludeFilters(), registry);
		scanner.setConsiderNestedRepositoryInterfaces(shouldConsiderNestedRepositories());
		scanner.setEnvironment(environment);
		scanner.setResourceLoader(loader);

		getExcludeFilters().forEach(it -> scanner.addExcludeFilter(it));

		//根据扫描的包路径，查找需要的BeanDefinition，也就是UserRepository
		return Streamable.of(() -> getBasePackages().stream()//
				.flatMap(it -> scanner.findCandidateComponents(it).stream()));
	}
}

RepositoryComponentProvider

RepositoryComponentProvider继承自ClassPathScanningCandidateComponentProvider，可以看到super.addIncludeFilter加入了Repository.class，这就是前面一直说的Repository接口。

class RepositoryComponentProvider extends ClassPathScanningCandidateComponentProvider {
	public RepositoryComponentProvider(Iterable<? extends TypeFilter> includeFilters, BeanDefinitionRegistry registry) {

		super(false);

		Assert.notNull(includeFilters, "Include filters must not be null!");
		Assert.notNull(registry, "BeanDefinitionRegistry must not be null!");

		this.registry = registry;

		if (includeFilters.iterator().hasNext()) {
			for (TypeFilter filter : includeFilters) {
				addIncludeFilter(filter);
			}
		} else {
			super.addIncludeFilter(new InterfaceTypeFilter(Repository.class));
			super.addIncludeFilter(new AnnotationTypeFilter(RepositoryDefinition.class, true, true));
		}

		addExcludeFilter(new AnnotationTypeFilter(NoRepositoryBean.class));
	}
	//根据包路径查找符合规则的BeanDefinition
	@Override
	public Set<BeanDefinition> findCandidateComponents(String basePackage) {

		Set<BeanDefinition> candidates = super.findCandidateComponents(basePackage);

		for (BeanDefinition candidate : candidates) {
			if (candidate instanceof AnnotatedBeanDefinition) {
				AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
			}
		}

		return candidates;
	}
}

通过ClassPathScanningCandidateComponentProvider的findCandidateComponents方法获取符合条件的BeanDefinition集合，在这里就是Repository接口子类的集合。

RepositoryBeanDefinitionBuilder

再回到RepositoryConfigurationDelegate的registerRepositoriesIn方法，获取到RepositoryConfiguration后，使用RepositoryBeanDefinitionBuilder的build方法将其转换为BeanDefinitionBuilder

class RepositoryBeanDefinitionBuilder {
	//将RepositoryConfiguration转换为BeanDefinitionBuilder
	public BeanDefinitionBuilder build(RepositoryConfiguration<?> configuration) {

		Assert.notNull(registry, "BeanDefinitionRegistry must not be null!");
		Assert.notNull(resourceLoader, "ResourceLoader must not be null!");

		//实际创建的是JpaRepositoryFactoryBean
		//这是在@EnableJpaRepositories注解中默认指定的
		BeanDefinitionBuilder builder = BeanDefinitionBuilder
				.rootBeanDefinition(configuration.getRepositoryFactoryBeanClassName());

		builder.getRawBeanDefinition().setSource(configuration.getSource());
		builder.addConstructorArgValue(configuration.getRepositoryInterface());
		builder.addPropertyValue("queryLookupStrategyKey", configuration.getQueryLookupStrategyKey());
		builder.addPropertyValue("lazyInit", configuration.isLazyInit());

		configuration.getRepositoryBaseClassName()//
				.ifPresent(it -> builder.addPropertyValue("repositoryBaseClass", it));

		NamedQueriesBeanDefinitionBuilder definitionBuilder = new NamedQueriesBeanDefinitionBuilder(
				extension.getDefaultNamedQueryLocation());
		configuration.getNamedQueriesLocation().ifPresent(definitionBuilder::setLocations);

		builder.addPropertyValue("namedQueries", definitionBuilder.build(configuration.getSource()));

		registerCustomImplementation(configuration).ifPresent(it -> {
			builder.addPropertyReference("customImplementation", it);
			builder.addDependsOn(it);
		});

		BeanDefinitionBuilder fragmentsBuilder = BeanDefinitionBuilder
				.rootBeanDefinition(RepositoryFragmentsFactoryBean.class);

		List<String> fragmentBeanNames = registerRepositoryFragmentsImplementation(configuration) //
				.map(RepositoryFragmentConfiguration::getFragmentBeanName) //
				.collect(Collectors.toList());

		fragmentsBuilder.addConstructorArgValue(fragmentBeanNames);

		builder.addPropertyValue("repositoryFragments",
				ParsingUtils.getSourceBeanDefinition(fragmentsBuilder, configuration.getSource()));

		RootBeanDefinition evaluationContextProviderDefinition = new RootBeanDefinition(
				ExtensionAwareEvaluationContextProvider.class);
		evaluationContextProviderDefinition.setSource(configuration.getSource());

		builder.addPropertyValue("evaluationContextProvider", evaluationContextProviderDefinition);

		return builder;
	}
}

JpaRepositoryFactoryBean

以上这些步骤就是通过BeanDefinitionBuilder构建出了JpaRepositoryFactoryBean，它的父类继承了InitializingBean，它实现了afterPropertiesSet方法，所以在实例化JpaRepositoryFactoryBean后，调用会进入到afterPropertiesSet方法

public class JpaRepositoryFactoryBean<T extends Repository<S, ID>, S, ID>
		extends TransactionalRepositoryFactoryBeanSupport<T, S, ID> {
	
	@Override
	protected RepositoryFactorySupport createRepositoryFactory(EntityManager entityManager) {
		return new JpaRepositoryFactory(entityManager);
	}
	
	@Override
	public void afterPropertiesSet() {

		Assert.state(entityManager != null,"EntityManager must not be null!");
		super.afterPropertiesSet();
	}
}

进而我们找到父类的afterPropertiesSet定义

public abstract class RepositoryFactoryBeanSupport<T extends Repository<S, ID>, S, ID>
		implements InitializingBean, RepositoryFactoryInformation<S, ID>, FactoryBean<T>, BeanClassLoaderAware,
		BeanFactoryAware, ApplicationEventPublisherAware {
	
	public void afterPropertiesSet() {
		//调用子类的实现，返回的是JpaRepositoryFactory
		this.factory = createRepositoryFactory();
		this.factory.setQueryLookupStrategyKey(queryLookupStrategyKey);
		this.factory.setNamedQueries(namedQueries);
		this.factory.setEvaluationContextProvider(evaluationContextProvider);
		this.factory.setBeanClassLoader(classLoader);
		this.factory.setBeanFactory(beanFactory);

		if (publisher != null) {
			this.factory.addRepositoryProxyPostProcessor(new EventPublishingRepositoryProxyPostProcessor(publisher));
		}

		repositoryBaseClass.ifPresent(this.factory::setRepositoryBaseClass);

		RepositoryFragments customImplementationFragment = customImplementation //
				.map(RepositoryFragments::just) //
				.orElseGet(RepositoryFragments::empty);

		RepositoryFragments repositoryFragmentsToUse = this.repositoryFragments //
				.orElseGet(RepositoryFragments::empty) //
				.append(customImplementationFragment);

		this.repositoryMetadata = this.factory.getRepositoryMetadata(repositoryInterface);
		//获取Repository的代理实现，即UserRepository的代理
		this.repository = Lazy.of(() -> this.factory.getRepository(repositoryInterface, repositoryFragmentsToUse));

		if (!lazyInit) {
			this.repository.get();
		}
	}
}

RepositoryFactorySupport

JpaRepositoryFactory的父类

/**
 1. 用于创建给定的Repotory的接口代理实现
*/
public abstract class RepositoryFactorySupport implements BeanClassLoaderAware, BeanFactoryAware {
	
	public <T> T getRepository(Class<T> repositoryInterface, RepositoryFragments fragments) {

		Assert.notNull(repositoryInterface, "Repository interface must not be null!");
		Assert.notNull(fragments, "RepositoryFragments must not be null!");

		//Repository的元数据，包含接口类型、主键类型、实体类型
		RepositoryMetadata metadata = getRepositoryMetadata(repositoryInterface);
		RepositoryComposition composition = getRepositoryComposition(metadata, fragments);
		RepositoryInformation information = getRepositoryInformation(metadata, composition);

		validate(information, composition);

		Object target = getTargetRepository(information);

		//创建UserRepository的代理，SimpleJpaRepository
		ProxyFactory result = new ProxyFactory();
		result.setTarget(target);
		result.setInterfaces(repositoryInterface, Repository.class, TransactionalProxy.class);

		//添加各种切面
		if (MethodInvocationValidator.supports(repositoryInterface)) {
			result.addAdvice(new MethodInvocationValidator());
		}

		result.addAdvice(SurroundingTransactionDetectorMethodInterceptor.INSTANCE);
		result.addAdvisor(ExposeInvocationInterceptor.ADVISOR);

		postProcessors.forEach(processor -> processor.postProcess(result, information));

		result.addAdvice(new DefaultMethodInvokingMethodInterceptor());

		ProjectionFactory projectionFactory = getProjectionFactory(classLoader, beanFactory);
		result.addAdvice(new QueryExecutorMethodInterceptor(information, projectionFactory));

		composition = composition.append(RepositoryFragment.implemented(target));
		result.addAdvice(new ImplementationMethodExecutionInterceptor(composition));

		return (T) result.getProxy(classLoader);
	}
}

调试可以看到，代理接口是UserRepository，代理类是SimpleJpaRepository
在这里插入图片描述
在实际使用userRepository的地方，可以看到它是一个Proxy，tatgetSource是SimpleJpaRepository@5652,与上一步创建的代理对象是同一个。
在这里插入图片描述
SimpleJpaRepository实际是对EntityManager调用的各种封装

结束

总结一下Repository的创建步骤

  1. 获取自定义的Repository接口并以BeanDefinition的形式呈现
  2. 将接口定义封装为RepositoryConfiguration
  3. 再转换为BeanDefinitionBuilder，从而创建JpaRepositoryFactoryBean实例
  4. 通过FactoryBean创建JpaRepositoryFactory实例
  5. 生成Repository接口的代理SimpleJpaRepository

自下而上，从左到右查看类图的走向，就是前面所述的流程。
在这里插入图片描述

猜你喜欢

转载自blog.csdn.net/f4761/article/details/84257371
今日推荐
国产云输入法——仅华为无云端数据上传安全问题
开源日报 | 工业开源项目OGG 1.0；姐姐，你要和我一起配置火狐吗；苹果AI遥遥落后？Fedora 40
开放签电子签章：停止新增，优化体验，前进更进（五一假期前工作）
开源日报 | 中学生开源前端动画引擎；全球首个Llama3 8B中文版开源模型；联想电脑恐出局；Linus讽刺AI炒作
“百模大战”必有一战 | 2024中国“百模大战”竞争格局分析
最强开源大模型 Llama 3 上架 Gitee AI
虽然老乡鸡开源的不是代码，但背后的原因却让人很暖心
周排行
决策树的部分理解
STM32软件IIC的实现
RocketMQ原理解析-HA
vue-动态路由（路由的传参和接参）
利用python对Excel中的特定数据提取并写入新表
【Ubuntu】 Ubuntu16.04搭建NFS服务
Elasticsearch基础操作与对应的curl命令行，python对接实现
JVM数据存储结构 & Java的值传递和址传递
yum命令使用指南
java基础（一）：java语法基础
每日归档
更多
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)
2024-04-17(5)
2024-04-16(70)
2024-04-15(42)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022