JPA的Repository操作数据库原理

在了解JPA的Repository原理之前，先了解一下EntityManager的应用，通过它可以开启一个事务，从而令之后的操作在保持在事务中。

public class JpaTest {

    EntityManagerFactory factory;

    @Before
    public void before() {
        // 从META-INF的persistence.xml获取持久化单元
        factory = Persistence.createEntityManagerFactory("hibernateJPA");
    }

    // 立即查询
    @Test
    public void testR() {
        EntityManager em = factory.createEntityManager();

        EntityTransaction tx = em.getTransaction();
        tx.begin();

        Customer customer = em.find(Customer.class, 1L);
        System.out.println("========================");
        System.out.println(customer);
        tx.commit();
    }
}

以Hibernate实现的JPA为例，通过JDK提供的动态代理机制，生成JPA的Repository接口的实现类，从如下的单元测试作为切入点，我们可以进一步跟踪JPA生成的动态代理是如何进行数据库操作的

@ContextConfiguration(classes = SpringDataJPAConfig.class)
@RunWith(SpringJUnit4ClassRunner.class)
public class SpringdataJpaTest {

    // jdk动态代理的实例
    @Autowired
    CustomerRepository repository;

    @Test
    public void testR() {
        Optional<Customer> byId = repository.findById(20L);
        System.out.println(byId.orElse(null));
    }
}

通过断点，可以看到注入的CustomerRepository是一个动态代理对象$Proxy，创建动态代理所需的接口InvocationHandler实现类采用org.springframework.aop.framework.JdkDynamicAopProxy类

动态代理类细节

进一步通过断点到JdkDynamicAopProxy类中，这是Spring提供的一个用于生成动态代理对象的工厂类，可以看到这个类中存在获取具体代理对象的方法，同时生成的动态代理对象调用目标方法的时候，也会相应的触发这个类中的拦截方法invoke，相关的代码如下：

final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
    // ...

    // 通过如下两个方法可以获取到当前类需要创建的代理对象
    @Override
    public Object getProxy() {
        return getProxy(ClassUtils.getDefaultClassLoader());
    }
    @Override
    public Object getProxy(@Nullable ClassLoader classLoader) {
        return Proxy.newProxyInstance(classLoader, this.proxiedInterfaces, this);
    }

    // ...

    // 当代理对象触发方法的调用时，会进入到这个方法，Spring在这里会构成一个调用链，
    // 并通过递归的方式，不断地触发调用链上的每一个方法
    @Override
    @Nullable
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // ...

        target = targetSource.getTarget();
        Class<?> targetClass = (target != null ? target.getClass() : null);

        List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

        if (chain.isEmpty()) {
                Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
                retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
        } else {
                MethodInvocation invocation =
                        new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
                retVal = invocation.proceed();
        }

        // ...
    }
}

仔细观察JdkDynamicAopProxy类中的targetSource属性，内部封装了org.springframework.data.jpa.repository.support.SimpleJpaRepository类，这是spring-data-jpa提供的通用Repository，类似上文举过的单元测试例子，它内部封装了EntityManager，通过后者就能够获取到当前项目中实现了JPA规范的Hibernate的SessionImpl对象，从而完成数据库操作，SimpleJpaRepository类如下：

@Repository
@Transactional(readOnly = true)
public class SimpleJpaRepository<T, ID> implements JpaRepositoryImplementation<T, ID> {

    // ...

    @Override
    public Optional<T> findById(ID id) {
        Assert.notNull(id, ID_MUST_NOT_BE_NULL);
        Class<T> domainType = getDomainClass();
        if (metadata == null) {
                return Optional.ofNullable(em.find(domainType, id));
        }
        LockModeType type = metadata.getLockModeType();
        Map<String, Object> hints = new HashMap<>();
        getQueryHints().withFetchGraphs(em).forEach(hints::put);
        return Optional.ofNullable(type == null ? em.find(domainType, id, hints) 
                                                : em.find(domainType, id, type, hints));
    }
}