import org.springframework.aop.aspectj.AbstractAspectJAdvice; //导入依赖的package包/类
@Override
public String toString() {
	StringBuilder sb = new StringBuilder();
	Advice advice = this.advisor.getAdvice();
	sb.append(ClassUtils.getShortName(advice.getClass()));
	sb.append(": ");
	if (this.advisor instanceof Ordered) {
		sb.append("order ").append(((Ordered) this.advisor).getOrder()).append(", ");
	}
	if (advice instanceof AbstractAspectJAdvice) {
		AbstractAspectJAdvice ajAdvice = (AbstractAspectJAdvice) advice;
		sb.append(ajAdvice.getAspectName());
		sb.append(", declaration order ");
		sb.append(ajAdvice.getDeclarationOrder());
	}
	return sb.toString();
}
 

import org.springframework.aop.aspectj.AbstractAspectJAdvice; //导入依赖的package包/类
/**
 * @param jndiUrl
 * @param bf
 * @return
 * @throws ClassNotFoundException
 * @throws NoSuchMethodException
 * @throws InstantiationException
 * @throws IllegalAccessException
 * @throws InvocationTargetException
 * @throws Exception
 */
public static Object makeBeanFactoryTriggerPCAH ( UtilFactory uf, String name, BeanFactory bf ) throws ClassNotFoundException,
        NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException, Exception {
    AspectInstanceFactory aif = Reflections.createWithoutConstructor(BeanFactoryAspectInstanceFactory.class);
    Reflections.setFieldValue(aif, "beanFactory", bf);
    Reflections.setFieldValue(aif, "name", name);
    AbstractAspectJAdvice advice = Reflections.createWithoutConstructor(AspectJAroundAdvice.class);
    Reflections.setFieldValue(advice, "aspectInstanceFactory", aif);

    // make readObject happy if it is called
    Reflections.setFieldValue(advice, "declaringClass", Object.class);
    Reflections.setFieldValue(advice, "methodName", "toString");
    Reflections.setFieldValue(advice, "parameterTypes", new Class[0]);

    AspectJPointcutAdvisor advisor = Reflections.createWithoutConstructor(AspectJPointcutAdvisor.class);
    Reflections.setFieldValue(advisor, "advice", advice);

    Class<?> pcahCl = Class
            .forName("org.springframework.aop.aspectj.autoproxy.AspectJAwareAdvisorAutoProxyCreator$PartiallyComparableAdvisorHolder");
    Object pcah = Reflections.createWithoutConstructor(pcahCl);
    Reflections.setFieldValue(pcah, "advisor", advisor);
    return uf.makeToStringTriggerUnstable(pcah);
}
 

import org.springframework.aop.aspectj.AbstractAspectJAdvice; //导入依赖的package包/类
@Override
public Object postProcessAfterInitialization(Object bean, String beanName)
		throws BeansException {
	if (bean instanceof Advised) {
		Advised advised = (Advised) bean;

		for (Advisor advisor : advised.getAdvisors()) {
			if (advisor instanceof AspectJPointcutAdvisor) {
				String foundName = ((AbstractAspectJAdvice) ((AspectJPointcutAdvisor) advisor)
						.getAdvice()).getAspectName();
				if (aspect.getName().equals(foundName)) {
					LOG.info(String.format("Found bean '%s' advised by %s; injecting", beanName, aspect));
					try {
						aspect.addAdvised(advised.getTargetSource().getTarget(), beanName);
					} catch (Exception e) {
						throw new RuntimeException(e);
					}
				}
			}
		}
	}
	return bean;
}
 

import org.springframework.aop.aspectj.AbstractAspectJAdvice; //导入依赖的package包/类
private Object extractPojo(MyService svc)
{
	Advised advisedBean = (Advised) svc;
	Advisor[] advisors = advisedBean.getAdvisors();
	for(Advisor advisor : advisors)
	{
		Advice advice = advisor.getAdvice();
		if(advice instanceof AbstractAspectJAdvice)
		{
			AbstractAspectJAdvice aaja = (AbstractAspectJAdvice) advice;
			Object target = aaja.getAspectInstanceFactory().getAspectInstance();
			return target;
		}
	}
	return null;
}
 

import org.springframework.aop.aspectj.AbstractAspectJAdvice; //导入依赖的package包/类
@Override
protected boolean shouldSkip(Class<?> beanClass, String beanName) {
	// TODO: Consider optimization by caching the list of the aspect names
	List<Advisor> candidateAdvisors = findCandidateAdvisors();
	for (Advisor advisor : candidateAdvisors) {
		if (advisor instanceof AspectJPointcutAdvisor) {
			if (((AbstractAspectJAdvice) advisor.getAdvice()).getAspectName().equals(beanName)) {
				return true;
			}
		}
	}
	return super.shouldSkip(beanClass, beanName);
}
 

import org.springframework.aop.aspectj.AbstractAspectJAdvice; //导入依赖的package包/类
private Advisor createAspectJAdvice(int advisorOrder, int adviceDeclarationOrder, String aspectName, AbstractAspectJAdvice advice) {
	advice.setDeclarationOrder(adviceDeclarationOrder);
	advice.setAspectName(aspectName);
	AspectJPointcutAdvisor advisor = new AspectJPointcutAdvisor(advice);
	advisor.setOrder(advisorOrder);
	return advisor;
}
 

import org.springframework.aop.aspectj.AbstractAspectJAdvice; //导入依赖的package包/类
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException
{
	boolean advised = bean instanceof Advised;
	if(advised)
	{
		Advised advisedBean = (Advised) bean;
		Advisor[] advisors = advisedBean.getAdvisors();
		for(Advisor advisor : advisors)
		{
			Advice advice = advisor.getAdvice();
			if(advice instanceof AbstractAspectJAdvice)
			{
				AbstractAspectJAdvice aaja = (AbstractAspectJAdvice) advice;
				Class<?> aspectPojoClass = aaja.getAspectJAdviceMethod().getDeclaringClass();
				String serviceType = annotationToServiceNames.get(aspectPojoClass);
				if(serviceType != null)
				{
					ObjectName oname;
					String onameString = getDomain(bean) + "." + serviceType + ":bean=" + beanName;
					try
					{
						/* as long as the aspect is marked prototype, each advised bean
						 * gets a new instance, as seen by the return value of this next 
						 * method call.  I've also checked that successive calls to the
						 * getAspectInstance() method return the same object.
						 */
						Object target = aaja.getAspectInstanceFactory().getAspectInstance();
						oname = new ObjectName(onameString);
						registerMBean(oname, target, beanName);
					}
					catch(Exception e)
					{
						logger.error("Cannot register mbean with oname [" + onameString +"]", e);
					}
				}
			}
		}
	}
	return bean;
}
 

import org.springframework.aop.aspectj.AbstractAspectJAdvice; //导入依赖的package包/类
@Override
protected boolean shouldSkip(Class beanClass, String beanName) {
	// TODO: Consider optimization by caching the list of the aspect names
	List<Advisor> candidateAdvisors = findCandidateAdvisors();
	for (Advisor advisor : candidateAdvisors) {
		if (advisor instanceof AspectJPointcutAdvisor) {
			if (((AbstractAspectJAdvice) advisor.getAdvice()).getAspectName().equals(beanName)) {
				return true;
			}
		}
	}
	return super.shouldSkip(beanClass, beanName);
}