public interface FactoryBean<T> {
    T getObject() throws Exception;
    Class<?> getObjectType();
    boolean isSingleton();
}

public class UserService {

    public void createUser(String username) {

        // 模拟业务处理
        System.out.println("Creating user: " + username);
    }

    public void deleteUser(String username) {

        // 模拟业务处理
        System.out.println("Deleting user: " + username);
    }
}

// 定义一个前置增强
public class LoggingBeforeAdvice implements MethodBeforeAdvice {
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("Before method: " + method.getName());
    }
}

// 定义一个后置增强
public class LoggingAfterAdvice implements AfterReturningAdvice {
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("After method: " + method.getName());
    }
}


// 定义一个 环绕增强
public class LoggingMethodInterceptor implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        // 方法执行前逻辑
        long startTime = System.currentTimeMillis();
        System.out.println(invocation.getMethod().getName()+ " 方法开始执行");


        // 通过反射执行目标方法
        Object result = invocation.proceed();

        // 方法执行后逻辑
        //System.out.println("After method: " + invocation.getMethod().getName());
        long endTime = System.currentTimeMillis();
        System.out.println(invocation.getMethod().getName()+ "方法执行时间: " + (endTime - startTime) + "ms");

        return result;
    }
}

public class CodingInActionApplication{

    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        // 获取代理对象
        UserService userService = (UserService) context.getBean("userServiceProxy");

        // 调用方法，观察 AOP 切面的效果
        userService.createUser("john");
        userService.deleteUser("john");

    }
}

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

String beanName = transformedBeanName(name);

protected Object getObjectForBeanInstance(
			Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {
 
		//如果是对FactoryBean的解引用，但bean对象不是FactoryBean，抛出异常
		if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
			throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
		}
 
		//如果Bean实例不是FactoryBean，或者指定名称是FactoryBean的解引用，也就是普通的bean调用，则直接返回当前的Bean实例  
		if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
			return beanInstance;
		}
		
		//处理对FactoryBean的调用
		Object object = null;
		if (mbd == null) {
			//从Bean工厂缓存中获取给定名称的实例对象
			object = getCachedObjectForFactoryBean(beanName);
		}
		if (object == null) {
			// Return bean instance from factory.
			FactoryBean factory = (FactoryBean) beanInstance;
			//如果从Bean工厂生产的Bean是单态模式的，则缓存
			if (mbd == null && containsBeanDefinition(beanName)) {
				mbd = getMergedLocalBeanDefinition(beanName);
			}
			boolean synthetic = (mbd != null && mbd.isSynthetic());
			//调用FactoryBeanRegistrySupport类的getObjectFromFactoryBean方法，实现FactoryBean生产Bean对象实例的过程  
			object = getObjectFromFactoryBean(factory, beanName, !synthetic);
		}
		return object;
	}

// Bean工厂生产Bean实例对象
protected Object getObjectFromFactoryBean(FactoryBean factory,
		String beanName, boolean shouldPostProcess) {
	// Bean工厂是单态模式，并且Bean工厂缓存中存在指定名称的Bean实例对象
	if (factory.isSingleton() && containsSingleton(beanName)) {
		synchronized (getSingletonMutex()) {
			// 直接从Bean工厂缓存中获取指定名称的Bean实例对象
			Object object = this.factoryBeanObjectCache.get(beanName);
			// Bean工厂缓存中没有指定名称的实例对象，则生产该实例对象
			if (object == null) {
				// 调用Bean工厂的getObject方法生产指定Bean的实例对象
				object = doGetObjectFromFactoryBean(factory, beanName,
						shouldPostProcess);
				// 将生产的实例对象添加到Bean工厂缓存中
				this.factoryBeanObjectCache.put(beanName,
						(object != null ? object : NULL_OBJECT));
			}
			return (object != NULL_OBJECT ? object : null);
		}
	}
	// 调用Bean工厂的getObject方法生产指定Bean的实例对象
	else {
		return doGetObjectFromFactoryBean(factory, beanName,
				shouldPostProcess);
	}
}

//调用Bean工厂的getObject方法生产指定Bean的实例对象  
   private Object doGetObjectFromFactoryBean(  
           final FactoryBean factory, final String beanName, final boolean shouldPostProcess)  
           throws BeanCreationException {  
       Object object;  
       try {  
           if (System.getSecurityManager() != null) {  
               AccessControlContext acc = getAccessControlContext();  
               try {  
                   //实现PrivilegedExceptionAction接口的匿名内置类  
                   //根据JVM检查权限，然后决定BeanFactory创建实例对象  
                   object = AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {  
                       public Object run() throws Exception {  
                               //调用BeanFactory接口实现类的创建对象方法  
                               return factory.getObject();  
                           }  
                       }, acc);  
               }  
               catch (PrivilegedActionException pae) {  
                   throw pae.getException();  
               }  
           }  
           else {  
           	//调用BeanFactory接口实现类的创建对象方法  
               object = factory.getObject();  
           }  
       }  
       catch (FactoryBeanNotInitializedException ex) {  
           throw new BeanCurrentlyInCreationException(beanName, ex.toString());  
       }  
       catch (Throwable ex) {  
           throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);  
       }  
       //创建出来的实例对象为null，或者因为单态对象正在创建而返回null  
       if (object == null && isSingletonCurrentlyInCreation(beanName)) {  
           throw new BeanCurrentlyInCreationException(  
                   beanName, "FactoryBean which is currently in creation returned null from getObject");  
       }  
       //为创建出来的Bean实例对象添加BeanPostProcessor后置处理器  
       if (object != null && shouldPostProcess) {  
           try {  
               object = postProcessObjectFromFactoryBean(object, beanName);  
           }  
           catch (Throwable ex) {  
               throw new BeanCreationException(beanName, "Post-processing of the FactoryBean's object failed", ex);  
           }  
       }  
       return object;  
   } 

 // 获取代理对象
UserService userService = (UserService) context.getBean("userServiceProxy");

public class SqlSessionFactoryBean implements FactoryBean<SqlSessionFactory>, InitializingBean, ApplicationListener<ApplicationEvent> {
    private static final Log LOGGER = LogFactory.getLog(SqlSessionFactoryBean.class);
...
public SqlSessionFactory getObject() throws Exception {
        if (this.sqlSessionFactory == null) {
            this.afterPropertiesSet();
        }
 
        return this.sqlSessionFactory;
    }
...
}