在了解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));
}
}
