首先介绍一下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> {
//符合某种规则的方法名
User findByFirstNameStartWith(String prefix);
Long countByLastname(String lastname);
}
接下来,不用自己写实现我们就可以直接使用UserRepository了,普通findOne或者自定义的findByLastName都已经实现了.
@Service
public class UserService{
@Autowired
private UserRepository userRepository;
public User getUser(String lastNamePrefix){
return userRepository.findByFirstNameStartWith(lastNamePrefix);
}
}
然后启动项目
@SpringBootApplication
@EnableJpaRepositories
public class JpaDemoApplication {
public static void main(String[] args) {
SpringApplication.run(JpaDemoApplication.class, args);
}
}
Spring Data Jpa是如何帮我们实现接口的呢?首先是前置条件:
- 准备JPA环境,如EntityManager和Hibernate的配置
然后Spring Data JPA启动,主要分为几步:
通过注解和包扫描获得配置信息 ,对应类为
AnnotationRepositoryConfigurationSource通过配置信息,向Spring注册Repository的FactoryBean的BeanDefinition,即
JpaRepositoryFactoryBean的BeanDefinitionSpring启动中,会根据BeanDefinition实例化FactoryBean,并调用它的getObject方法
在getObject方法中,Spring Data JPA解析方法名并生成代理.
接下来,我们从@EnableJpaRepositories开始,可以看到在它上边有@Import(JpaRepositoriesRegistrar.class)注解,其中JpaRepositoriesRegistrar是ImportBeanDefinitionRegistrar的子类.
其中ImportBeanDefintionRegistrar是Spring提供的策略,spring会在加载BeanDefinition的时候调用它的方法:
public void registerBeanDefinitions(
AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry);
所以我们接下来看一下Spring Data JPA如何实现这个方法:
public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry registry) {
//获得基于注解的配置信息,如注解信息,要扫描的包,要扫描的注解等
AnnotationRepositoryConfigurationSource configurationSource = new AnnotationRepositoryConfigurationSource(
annotationMetadata, getAnnotation(), resourceLoader, environment);
//这个类用来做一些准备工作,不是本文的重点
RepositoryConfigurationExtension extension = getExtension();
//实例化一个委托对象,用来完成整体的注册逻辑.
RepositoryConfigurationDelegate delegate = new RepositoryConfigurationDelegate(configurationSource, resourceLoader,
environment);
//重点,调用委托对象,完成实际的注册逻辑,也就是上边的第一步和第二步
delegate.registerRepositoriesIn(registry, extension);
}
接下来看RepositoryConfigurationDelegate的关键方法,delegate.registerRepositoriesIn(registry, extension)
//省略了一些代码
public List<BeanComponentDefinition> registerRepositoriesIn(BeanDefinitionRegistry registry,
RepositoryConfigurationExtension extension) {
//调用extension准备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
//由配置信息,主要是接口名称,生成基础的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)
这里调用层数比较深,首先是取的要扫描的包,然后对每一个包下边进行扫描.我们直接看扫描给定包的代码
//省略了不关键代码
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)) {
//其实这里有用的信息只有接口的名字和注解
ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
sbd.setResource(resource);
sbd.setSource(resource);
candidates.add(sbd);
}
}
return candidates;
}
到此,第一步完成,我们知道了Spring Data JPA如何通过包扫描获得哪些类需要被代理.
接下来我们进入第二步,简略的看一下生成FactoryBeanDefinitionBuilder的过程,FactoryBean的实际类型是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);
//使用包扫描的结果,设置interface的名称,懒加载,基础的Repository的名称等.
builder.getRawBeanDefinition().setSource(configuration.getSource());
//设置repositoryInterface,就是我们自定义的Repository,比如UserRepository
builder.addPropertyValue("repositoryInterface", configuration.getRepositoryInterface());
//设置其他信息
builder.addPropertyValue("queryLookupStrategyKey", configuration.getQueryLookupStrategyKey());
builder.addPropertyValue("lazyInit", configuration.isLazyInit());
builder.addPropertyValue("repositoryBaseClass", configuration.getRepositoryBaseClassName());
//省略剩余代码
}
之后extension还为FactoryBean设置了EntityManager.
这里生成的BeanDefinitionBuilder会生成实际的RepositoryFactoryBean的BeanDefinition,然后被注册到Spring上下文中.
到这里Spring Data JPA的第二步,注册FactoryBean的过程就结束了.
随后我们进入第三步,Spring会根据我们注册的BeanDefinition实例化JpaRepositoryFactoryBean,并调用它的getObject方法获得实际的Repository代理.具体的过程请参考Spring Framework的相关介绍
接下来我们进入第四步,生成Repository的重任交到了JpaRepositoryFactoryBean手中.JpaRepositoryFactoryBean 调用下面这个方法生成Repository的代理
private T initAndReturn() {
//这里是个单例模式,假如还没有生成,就生成一个
if (this.repository == null) {
this.repository = this.factory.getRepository(repositoryInterface, customImplementation);
}
//已经生成了就直接返回
return this.repository;
}
可以看到这里把Repository的创建委托给了成员变量factory,这里factory的实际类型是JpaRepositoryFactory,我们看下factory是如何创建Repository的.
public <T> T getRepository(Class<T> repositoryInterface, Object customImplementation) {
//省略一些不重要的代码
//这里是重点,调用工厂方法获得被代理对象,实际类型是SimpleJpaRepository
Object target = getTargetRepository(information);
//开始创建代理
ProxyFactory result = new ProxyFactory();
//设置代理目标
result.setTarget(target);
//设置代理所实现接口,即我们自定义的接口
result.setInterfaces(new Class[] { repositoryInterface, Repository.class });
//省略一些代码
//向代理添加重要的MethonInvoker,用来判断方法如何执行
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的浅层封装,当调用Repository对象的delete或者getOne等通用方法是,会委托到它这里来执行.
接下来只剩最后一个问题,我们自定义的方法如何执行呢?
result.addAdvice(new QueryExecutorMethodInterceptor(information, customImplementation, target));
可以看到Proxy被添加了一个MethodInvoker叫QueryExecutorMethodInterceptor.
它的invoke代码调用了内部的doInvoke,我们来看它的doInvoke代码,这段代码非常清楚.
private Object doInvoke(MethodInvocation invocation) throws Throwable {
Method method = invocation.getMethod();
Object[] arguments = invocation.getArguments();
//如果用户自己实现的方法(我们今天没有提到),则调用用户自己给的实现
if (isCustomMethodInvocation(invocation)) {
Method actualMethod = repositoryInformation.getTargetClassMethod(method);
return executeMethodOn(customImplementation, actualMethod, arguments);
}
//如果是用户用接口定义的代码,则在querys中找一个方法然后执行
if (hasQueryFor(method)) {
return queries.get(method).execute(arguments);
}
//最后,用户没有声明的代码,如findOne,delete之类的,调用SimpleJpaRepository实现
Method actualMethod = repositoryInformation.getTargetClassMethod(method);
return executeMethodOn(target, actualMethod, arguments);
}
那querys是什么呢?
private final Map<Method, RepositoryQuery> queries = new ConcurrentHashMap<Method, RepositoryQuery>();
是一个Map,记录了用户自定义方法和它对应的实际query.因此通过查询它可以获得实际的Query.
至此,Repository的Proxy已经为运行做好了准备.
这就是本文的全部内容.如果对Querys是如何生成的感兴趣,请阅读QueryExecutorMethodInterceptor的源码.
