首先介紹一下spring data jpa
這是Spring Data JPA提供的一個接口
public interface CrudRepository<T, ID extends Serializable> extends Repository<T, ID> {
<S extends T> S save(S entity);
boolean exists(ID id);
Iterable<T> findAll();
long count();
void delete(T entity);
void delete(Iterable<? extends T> entities);
//省略其他方法
}
下面是我們自己拓展的接口
public interface UserRepository extends CrudRepository<User, Long> {
//符合某種規(guī)則的方法名
User findByFirstNameStartWith(String prefix);
Long countByLastname(String lastname);
}
接下來,不用自己寫實(shí)現(xiàn)我們就可以直接使用UserRepository了,普通findOne或者自定義的findByLastName都已經(jīng)實(shí)現(xiàn)了.
@Service
public class UserService{
@Autowired
private UserRepository userRepository;
public User getUser(String lastNamePrefix){
return userRepository.findByFirstNameStartWith(lastNamePrefix);
}
}
然后啟動項(xiàng)目
@SpringBootApplication
@EnableJpaRepositories
public class JpaDemoApplication {
public static void main(String[] args) {
SpringApplication.run(JpaDemoApplication.class, args);
}
}
Spring Data Jpa是如何幫我們實(shí)現(xiàn)接口的呢?首先是前置條件:
- 準(zhǔn)備JPA環(huán)境,如EntityManager和Hibernate的配置
然后Spring Data JPA啟動,主要分為幾步:
通過注解和包掃描獲得配置信息 ,對應(yīng)類為
AnnotationRepositoryConfigurationSource通過配置信息,向Spring注冊Repository的FactoryBean的BeanDefinition,即
JpaRepositoryFactoryBean的BeanDefinitionSpring啟動中,會根據(jù)BeanDefinition實(shí)例化FactoryBean,并調(diào)用它的getObject方法
在getObject方法中,Spring Data JPA解析方法名并生成代理.
接下來,我們從@EnableJpaRepositories開始,可以看到在它上邊有@Import(JpaRepositoriesRegistrar.class)注解,其中JpaRepositoriesRegistrar是ImportBeanDefinitionRegistrar的子類.
其中ImportBeanDefintionRegistrar是Spring提供的策略,spring會在加載BeanDefinition的時候調(diào)用它的方法:
public void registerBeanDefinitions(
AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry);
所以我們接下來看一下Spring Data JPA如何實(shí)現(xiàn)這個方法:
public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry registry) {
//獲得基于注解的配置信息,如注解信息,要掃描的包,要掃描的注解等
AnnotationRepositoryConfigurationSource configurationSource = new AnnotationRepositoryConfigurationSource(
annotationMetadata, getAnnotation(), resourceLoader, environment);
//這個類用來做一些準(zhǔn)備工作,不是本文的重點(diǎn)
RepositoryConfigurationExtension extension = getExtension();
//實(shí)例化一個委托對象,用來完成整體的注冊邏輯.
RepositoryConfigurationDelegate delegate = new RepositoryConfigurationDelegate(configurationSource, resourceLoader,
environment);
//重點(diǎn),調(diào)用委托對象,完成實(shí)際的注冊邏輯,也就是上邊的第一步和第二步
delegate.registerRepositoriesIn(registry, extension);
}
接下來看RepositoryConfigurationDelegate的關(guān)鍵方法,delegate.registerRepositoriesIn(registry, extension)
//省略了一些代碼
public List<BeanComponentDefinition> registerRepositoriesIn(BeanDefinitionRegistry registry,
RepositoryConfigurationExtension extension) {
//調(diào)用extension準(zhǔn)備JPA的上下文
extension.registerBeansForRoot(registry, configurationSource);
//生成Repository的BeanDefinitionBuilder的工具類
RepositoryBeanDefinitionBuilder builder = new RepositoryBeanDefinitionBuilder(registry, extension, resourceLoader,
environment);
//extension.getRepositoryConfigurations方法完成剛剛說的第一步,包掃描,讀取配置.找出有哪些類需要Spring Data JPA生成代理
for (RepositoryConfiguration<? extends RepositoryConfigurationSource> configuration : extension
.getRepositoryConfigurations(configurationSource, resourceLoader, inMultiStoreMode)) {
//接下來開始第二步,一個一個地生成RepositoryFactoryBean的Definition
//由配置信息,主要是接口名稱,生成基礎(chǔ)的DefinitionBuilder
BeanDefinitionBuilder definitionBuilder = builder.build(configuration);
//配置EntityManager
extension.postProcess(definitionBuilder, configurationSource);
//獲得FactoryBean的Definition
AbstractBeanDefinition beanDefinition = definitionBuilder.getBeanDefinition();
String beanName = beanNameGenerator.generateBeanName(beanDefinition, registry);
//注冊FactoryBean的Definition
registry.registerBeanDefinition(beanName, beanDefinition);
}
}
接下來我們深入第一步,看看包掃描是怎么做的,入口是extension.getRepositoryConfigurations(configurationSource, resourceLoader, inMultiStoreMode)
這里調(diào)用層數(shù)比較深,首先是取的要掃描的包,然后對每一個包下邊進(jìn)行掃描.我們直接看掃描給定包的代碼
//省略了不關(guān)鍵代碼
public Set<BeanDefinition> findCandidateComponents(String basePackage) {
Set<BeanDefinition> candidates = new LinkedHashSet<BeanDefinition>();
String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
resolveBasePackage(basePackage) + "/" + this.resourcePattern;
Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath);
for (Resource resource : resources) {
if (resource.isReadable()) {
MetadataReader metadataReader =this.metadataReaderFactory.getMetadataReader(resource);
if (isCandidateComponent(metadataReader)) {
//其實(shí)這里有用的信息只有接口的名字和注解
ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
sbd.setResource(resource);
sbd.setSource(resource);
candidates.add(sbd);
}
}
return candidates;
}
到此,第一步完成,我們知道了Spring Data JPA如何通過包掃描獲得哪些類需要被代理.
接下來我們進(jìn)入第二步,簡略的看一下生成FactoryBeanDefinitionBuilder的過程,FactoryBean的實(shí)際類型是JpaRepositoryFactoryBean
public BeanDefinitionBuilder build(RepositoryConfiguration<?> configuration) {
//這里的FactoryBeanName為JpaRepositoryFactoryBean
String factoryBeanName = configuration.getRepositoryFactoryBeanName();
factoryBeanName = StringUtils.hasText(factoryBeanName) ? factoryBeanName : extension
.getRepositoryFactoryClassName();
//生成FactoryBean的DefinitionBuilder
BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(factoryBeanName);
//使用包掃描的結(jié)果,設(shè)置interface的名稱,懶加載,基礎(chǔ)的Repository的名稱等.
builder.getRawBeanDefinition().setSource(configuration.getSource());
//設(shè)置repositoryInterface,就是我們自定義的Repository,比如UserRepository
builder.addPropertyValue("repositoryInterface", configuration.getRepositoryInterface());
//設(shè)置其他信息
builder.addPropertyValue("queryLookupStrategyKey", configuration.getQueryLookupStrategyKey());
builder.addPropertyValue("lazyInit", configuration.isLazyInit());
builder.addPropertyValue("repositoryBaseClass", configuration.getRepositoryBaseClassName());
//省略剩余代碼
}
之后extension還為FactoryBean設(shè)置了EntityManager.
這里生成的BeanDefinitionBuilder會生成實(shí)際的RepositoryFactoryBean的BeanDefinition,然后被注冊到Spring上下文中.
到這里Spring Data JPA的第二步,注冊FactoryBean的過程就結(jié)束了.
隨后我們進(jìn)入第三步,Spring會根據(jù)我們注冊的BeanDefinition實(shí)例化JpaRepositoryFactoryBean,并調(diào)用它的getObject方法獲得實(shí)際的Repository代理.具體的過程請參考Spring Framework的相關(guān)介紹
接下來我們進(jìn)入第四步,生成Repository的重任交到了JpaRepositoryFactoryBean手中.JpaRepositoryFactoryBean 調(diào)用下面這個方法生成Repository的代理
private T initAndReturn() {
//這里是個單例模式,假如還沒有生成,就生成一個
if (this.repository == null) {
this.repository = this.factory.getRepository(repositoryInterface, customImplementation);
}
//已經(jīng)生成了就直接返回
return this.repository;
}
可以看到這里把Repository的創(chuàng)建委托給了成員變量factory,這里factory的實(shí)際類型是JpaRepositoryFactory,我們看下factory是如何創(chuàng)建Repository的.
public <T> T getRepository(Class<T> repositoryInterface, Object customImplementation) {
//省略一些不重要的代碼
//這里是重點(diǎn),調(diào)用工廠方法獲得被代理對象,實(shí)際類型是SimpleJpaRepository
Object target = getTargetRepository(information);
//開始創(chuàng)建代理
ProxyFactory result = new ProxyFactory();
//設(shè)置代理目標(biāo)
result.setTarget(target);
//設(shè)置代理所實(shí)現(xiàn)接口,即我們自定義的接口
result.setInterfaces(new Class[] { repositoryInterface, Repository.class });
//省略一些代碼
//向代理添加重要的MethonInvoker,用來判斷方法如何執(zhí)行
result.addAdvice(new QueryExecutorMethodInterceptor(information, customImplementation, target));
//返回生成好的代理
return (T) result.getProxy(classLoader);
}
可以看到,每一個我們自定義的Reposiory,背后都有一個被代理對象叫SimpleJpaRepository.我們來看它的一些方法
@Repository
@Transactional(readOnly = true)
public class SimpleJpaRepository<T, ID extends Serializable> implements ... {
@Transactional
public void delete(T entity) {
Assert.notNull(entity, "The entity must not be null!");
//這里的em即EntityManager
em.remove(em.contains(entity) ? entity : em.merge(entity));
}
@Override
public T getOne(ID id) {
Assert.notNull(id, ID_MUST_NOT_BE_NULL);
return em.getReference(getDomainClass(), id);
}
//省略其他方法
}
終于看到了我們熟悉的代碼! 到了這一步我們知道,SimpleJpaRepository是對EntityManager的淺層封裝,當(dāng)調(diào)用Repository對象的delete或者getOne等通用方法是,會委托到它這里來執(zhí)行.
接下來只剩最后一個問題,我們自定義的方法如何執(zhí)行呢?
result.addAdvice(new QueryExecutorMethodInterceptor(information, customImplementation, target));
可以看到Proxy被添加了一個MethodInvoker叫QueryExecutorMethodInterceptor.
它的invoke代碼調(diào)用了內(nèi)部的doInvoke,我們來看它的doInvoke代碼,這段代碼非常清楚.
private Object doInvoke(MethodInvocation invocation) throws Throwable {
Method method = invocation.getMethod();
Object[] arguments = invocation.getArguments();
//如果用戶自己實(shí)現(xiàn)的方法(我們今天沒有提到),則調(diào)用用戶自己給的實(shí)現(xiàn)
if (isCustomMethodInvocation(invocation)) {
Method actualMethod = repositoryInformation.getTargetClassMethod(method);
return executeMethodOn(customImplementation, actualMethod, arguments);
}
//如果是用戶用接口定義的代碼,則在querys中找一個方法然后執(zhí)行
if (hasQueryFor(method)) {
return queries.get(method).execute(arguments);
}
//最后,用戶沒有聲明的代碼,如findOne,delete之類的,調(diào)用SimpleJpaRepository實(shí)現(xiàn)
Method actualMethod = repositoryInformation.getTargetClassMethod(method);
return executeMethodOn(target, actualMethod, arguments);
}
那querys是什么呢?
private final Map<Method, RepositoryQuery> queries = new ConcurrentHashMap<Method, RepositoryQuery>();
是一個Map,記錄了用戶自定義方法和它對應(yīng)的實(shí)際query.因此通過查詢它可以獲得實(shí)際的Query.
至此,Repository的Proxy已經(jīng)為運(yùn)行做好了準(zhǔn)備.
這就是本文的全部內(nèi)容.如果對Querys是如何生成的感興趣,請閱讀QueryExecutorMethodInterceptor的源碼.
