Spring data jpa - Franclyn's site

参考链接

数据如何注入

spring 在启动的时候会实例化一个 Repositories，它会去扫描所有的 class，然后找出由我们定义的、继承自org.springframework.data.repository.Repositor的接口，然后遍历这些接口，针对每个接口依次创建如下几个实例:

SimpleJpaRespositry —— 用来进行默认的 DAO 操作，是所有 Repository 的默认实现
JpaRepositoryFactoryBean —— 装配 bean，装载了动态代理 Proxy，会以对应的 DAO 的 beanName 为 key 注册到DefaultListableBeanFactory中，在需要被注入的时候从这个 bean 中取出对应的动态代理 Proxy 注入给 DAO
JdkDynamicAopProxy —— 动态代理对应的InvocationHandler，负责拦截 DAO 接口的所有的方法调用，然后做相应处理，比如findByUsername被调用的时候会先经过这个类的 invoke 方法

在JpaRepositoryFactoryBean.getRepository()方法被调用的过程中，还是在实例化QueryExecutorMethodInterceptor这个拦截器的时候，spring 会去为我们的方法创建一个PartTreeJpaQuery，在它的构造方法中同时会实例化一个PartTree对象。PartTree定义了一系列的正则表达式，全部用于截取方法名，通过方法名来分解查询的条件，排序方式，查询结果等等，这个分解的步骤是在进程启动时加载 Bean 的过程中进行的，当执行查询的时候直接取方法对应的PartTree用来进行 sql 的拼装，然后进行 DB 的查询，返回结果。

到此为止，我们整个JpaRepository接口相关的链路就算走通啦，简单的总结如下：
spring 会在启动的时候扫描所有继承自 Repository 接口的 DAO 接口，然后为其实例化一个动态代理，同时根据它的方法名、参数等为其装配一系列DB操作组件，在需要注入的时候为对应的接口注入这个动态代理，在 DAO 方法被调用的时会走这个动态代理，然后经过一系列的方法拦截路由到最终的 DB 操作执行器JpaQueryExecution，然后拼装 sql，执行相关操作，返回结果。

然后Spring Data JPA启动,主要分为几步:

通过注解和包扫描获得配置信息 ,对应类为AnnotationRepositoryConfigurationSource
通过配置信息,向Spring注册Repository的FactoryBean的BeanDefinition,即JpaRepositoryFactoryBean的BeanDefinition
Spring启动中,会根据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.

数据如何注入

发送评论 编辑评论

发送评论编辑评论