上一章写到 时候谈到   personRepository.getOne(id) ，在调用 proxy-> aop ReflectiveMethodInvocation. proceed()   一系列的interceptorOrInterceptionAdvice 后，然后调用  SimpleJpaRepository.getOne（id）--> SessionImpl.load(class,id),现在你只需要知道从这儿开始就可以了。

      JavassistProxyFactory#getProxy(Serializable, SessionImplementor),这里的JavassistProxyFactory这类是在Hibernate启动的时候创建的，由EntityPersister 创建的。一个POJO对应有一个EntityPersister，一个EntityPersister对应有一个ProxyFactory（JavassistProxyFactory）。

             如何获取代理对象：JavassistProxyFactory在Hibernate启动的时候就创建了，创建之后，EntityPersister还对它进行了初始化（JavassistProxyFactory#postInstance(……);)这部分如下

   SessionImpl.load(class,id)  后面的 DefaultLoadEventListener.proxyOrLoad()  选择相关的proxy,其实 每个都类都有自己的一个ProxyFactory（javassist.util.proxy.ProxyFactory）。这个对象用来生产Proxy对象，生产该POJO的代理对象。在代理实例上处理方法调用并返回结果。在与方法关联的代理实例上调用方法时，将在调用处理程序上调用此方法，JavassistLazyInitializer 执行 JavassistLazyInitializer.invoke(...)

@Override
public Object invoke(
final Object proxy,
final Method thisMethod,
final Method proceed,
final Object[] args) throws Throwable {
if ( this.constructed ) {
// HHH-10922 - Internal calls to bytecode enhanced methods cause proxy to be initialized
if ( thisMethod.getName().startsWith( "$$_hibernate_" ) ) {
return proceed.invoke( proxy, args );
}


Object result;
try {
result = this.invoke( thisMethod, args, proxy );
}
catch ( Throwable t ) {
throw new Exception( t.getCause() );
}
if ( result == INVOKE_IMPLEMENTATION ) {
Object target = getImplementation();
final Object returnValue;
try {
if ( ReflectHelper.isPublic( persistentClass, thisMethod ) ) {
if ( !thisMethod.getDeclaringClass().isInstance( target ) ) {
throw new ClassCastException(
target.getClass().getName()
+ " incompatible with "
+ thisMethod.getDeclaringClass().getName()
);
}
returnValue = thisMethod.invoke( target, args );
}
else {
thisMethod.setAccessible( true );
returnValue = thisMethod.invoke( target, args );
}

if ( returnValue == target ) {
if ( returnValue.getClass().isInstance( proxy ) ) {
return proxy;
}
else {
LOG.narrowingProxy( returnValue.getClass() );
}
}
return returnValue;
}
catch ( InvocationTargetException ite ) {
throw ite.getTargetException();
}
}
else {
return result;
}
}
else {
// while constructor is running
if ( thisMethod.getName().equals( "getHibernateLazyInitializer" ) ) {
return this;
}
else {
return proceed.invoke( proxy, args );
}
}
}

为什么这样干，都是为了延迟加载对象，所以

但是，这个是回对象不是需要的，需要自动过滤掉 hibernateLazyInitializer 属性。一般在返回给前端领域对象vo 之前，需要对象未必完全符合，一般都需要组装一次加工，完成目标需要数据格式。

看看，仅仅需要一个对象，就完成  多次 aop 代理，在aop interceptor 链式中，然后后面也是层层proxy,至少四层proxy，性能消耗肯定是有的。

参考文章：

 http://blog.csdn.net/zteny/article/details/13991523