Spring AOP，应该不会有比这更详细的介绍了！

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyFactory {

 private static ProxyFactory instance = new ProxyFactory();
 private ProxyFactory() {}
 
 public static ProxyFactory getInstance() {
  return instance;
 }
 
 @SuppressWarnings("unchecked")
 public <T> T create(final T t) {
  return (T) Proxy.newProxyInstance(t.getClass().getClassLoader(), t.getClass().getInterfaces(), new InvocationHandler() {

   /**
    * 当使用创建的代理对象执行其中的方法时，都会转换为调用与代理对象绑定的InvocationHandler对象的invoke方法，
    * 这样我们就可以在这个方法里面对调用情况进行一些特定的处理逻辑
    */
   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    System.out.println("正在调用的方法是：" + method);
    //1、加入对调用方法前的处理逻辑
    //...
    Object result = null;
    try {
     //2、正常的调用目标对象的目标方法
     result = method.invoke(t, args);
     //3、可加入正常调用后的处理逻辑
     //...
    } catch (Exception e) {
     //4、可加入目标对象的方法调用抛出异常后的处理逻辑
     //..
    } finally {
     //5、可加入目标对象的方法执行完成后的处理逻辑，此逻辑不论是否抛出异常都将执行
    }
    return result;
   }
   
  });
 }
 
}

@Test
public void test1() {
 ProxyFactory proxyFactory = ProxyFactory.getInstance();
 //创建一个实现了UserService接口的对象
 UserService userService = new UserServiceImpl();
 //创建一个基于userService对象的代理对象
 UserService proxy = proxyFactory.create(userService);
 //调用代理对象的某个方法
 User user = proxy.findById(1);
 System.out.println(user);
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

 <context:annotation-config/>
 <context:component-scan base-package="com.elim.test"/>
 <!-- 启用对Aspectj注解的支持 -->
    <aop:aspectj-autoproxy/>

</beans>

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {

}

@Aspect
@Component
public class MyAspect {
 
}

@Aspect
@Component
public class MyAspect {

 @Pointcut("execution(* add(..))")
 private void pointcut() {}
 
}

@Aspect
@Component
public class MyAspect {

 @Pointcut("execution(* add(..))")
 private void pointcut() {}
 
 @Before("com.elim.test.spring.aop.MyAspect.pointcut()")
 private void before(JoinPoint joinPoint) {
  System.out.println(joinPoint.getTarget() + "----------------------Before---------------------");
 }
 
}

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {

 @Autowired
 private UserService userService;
 
 @Test
 public void test1() {
  User user = new User(1, "ZhangSan");
  userService.add(user);
 }
 
}

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? 
 name-pattern(param-pattern) throws-pattern?)

@Component
@Aspect
public class MyAspect {

 @Pointcut("execution(* add(..))")
 private void beforeAdd() {}
 
 @Before("beforeAdd()")
 public void before() {
  System.out.println("-----------before-----------");
 }
 
}

@Before("com.elim.spring.aop.service.MyService.add()")
public void before2() {
 System.out.println("-----------before2-----------");
}

/**
 * 所有的add方法的外部执行时
 */
@Before("execution(* add())")
public void beforeExecution() {
 System.out.println("-------------before execution---------------");
}

@Before("bean(userService)")
public void before() {
 System.out.println("-----before with pointcut expression: bean(userService)------");
}

@Before("bean(userService)")
public void before(JoinPoint joinPoint) {
 System.out.println("-----before with pointcut expression: bean(userService)------");
 joinPoint.getArgs();//获取当前目标方法调用传递的参数
 joinPoint.getSignature();//获取当前目标方法的签名，通过它可以获取到目标方法名
 joinPoint.getThis();//获取AOP生成的代理对象
 joinPoint.getTarget();//获取被代理对象，即目标对象
 System.out.println(joinPoint.getArgs());
 System.out.println(joinPoint.getSignature().getName());
 System.out.println(joinPoint.getThis().getClass());
 System.out.println(joinPoint.getTarget().getClass());
 System.out.println(joinPoint.toString());
}

@AfterReturning(value="bean(userService)", returning="returnValue")
public void afterReturning(Object returnValue) {
 System.out.println("-----after returning with pointcut expression: bean(userService)------");
 System.out.println("-----return value is: " + returnValue);
}

@AfterThrowing(value="bean(userService)", throwing="ex")
public void afterThrowing(Exception ex) {
 System.out.println("-----after throwing with pointcut expression: bean(userService)------" + ex);
}

@After("bean(userService)")
public void after() {
 System.out.println("-----after with pointcut expression: bean(userService)------");
}

@Around("bean(userService)")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
 System.out.println("-----around with pointcut expression: bean(userService)------");
 System.out.println("---------------------调用前---------------------");
 Object result = pjp.proceed();
 System.out.println("---------------------调用后---------------------");
 return result;
}

@Around("bean(userService)")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
 System.out.println("-----around with pointcut expression: bean(userService)------");
 System.out.println("---------------------调用前---------------------");
 Object[] params = new Object[]{15};
 Object result = pjp.proceed(params);//可以调整目标方法调用时传递的参数
 System.out.println("---------------------调用后---------------------");
 return result;
}

@Before(value="bean(userService) && execution(* findById(java.lang.Integer)) && args(id)", argNames="id")
public void beforeWithParam(JoinPoint joinPoint, Integer id) {
 System.out.println(this.getClass().getName()+" ID is : " + id);
}

@Before(value="bean(userService) && args(id)", argNames="id")
public void beforeWithParam2(int id) {
 System.out.println(this.getClass().getName()+" ID is : " + id);
}

@Before(value="bean(userService) && args(id,..)", argNames="id")
public void beforeWithParam2(int id) {
 System.out.println(this.getClass().getName()+" ID is : " + id);
}

@Before(value="bean(userService) && args(name, sex)", argNames="sex, name")
public void beforeWithParam3(int sex1, String name1) {
 System.out.println("sex is : " + sex1);
 System.out.println("name is : " + name1);
}

@Before(value="bean(userService) && args(id)")
public void beforeWithParam2(int id) {
 System.out.println(this.getClass().getName()+" ID is : " + id);
}

@Before("this(userService)")
public void beforeWithParam4(IUserService userService) {
 //this对象应该是一个代理对象
 System.out.println(this.getClass().getName()+"==============传递this对象： " + userService.getClass());
}

@Before("this(userService) && args(id)")
public void beforeWithParam5(IUserService userService, int id) {
 System.out.println(this.getClass().getName()+"===========" + id + "==============" + userService.getClass());
}

@Before("target(userService)")
public void beforeWithParam6(IUserService userService) {
 System.out.println(this.getClass().getName()+"==============传递target对象： " + userService.getClass());
}

@Before("@annotation(annotation)")
public void beforeWithParam7(MyAnnotation annotation) {
 System.out.println(this.getClass().getName()+"==============传递标注在方法上的annotation： " + annotation.annotationType().getName());
}

 public <T> void testParam(T param);

@Before("execution(void testParam(..)) && args(param)")
public void beforeWithParam8(Integer param) {
 System.out.println("pointcut expression[args(param)]--------------param:" + param);
}

public interface CommonParent {

 public void doSomething();
 
}
public class CommonParentImpl implements CommonParent {

 public void doSomething() {
  System.out.println("-----------do something------------");
 }

}

@Component
@Aspect
public class DeclareParentsAspect {

 @DeclareParents(value="com.elim.spring.aop.service..*", defaultImpl=CommonParentImpl.class)
 private CommonParent commonParent;
 
 @Before("bean(userService) && this(commonParent)")
 public void beforeUserService(CommonParent commonParent) {
  commonParent.doSomething();
 }
 
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:p="http://www.springframework.org/schema/p" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:context="http://www.springframework.org/schema/context"
 xmlns:aop="http://www.springframework.org/schema/aop"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
     http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
     http://www.springframework.org/schema/context
     http://www.springframework.org/schema/context/spring-context-4.1.xsd
     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd">

</beans>

<bean id="schemaBasedAspect" class="com.elim.spring.aop.aspect.SchemaBasedAspect"/>

<!-- 基于XML的AOP配置是基于config元素开始的 -->
<aop:config>
 <!-- 定义切面 -->
 <aop:aspect id="aspect1" ref="schemaBasedAspect" order="1">
 </aop:aspect>
</aop:config>

<aop:config>
 <aop:pointcut expression="bean(userService)" id="userServicePointCut2"/>
 <!-- 定义切面 -->
 <aop:aspect id="aspect1" ref="schemaBasedAspect" order="1">
  <aop:pointcut expression="bean(userService)" id="userServicePointCut"/>
 </aop:aspect>
</aop:config>

<aop:pointcut expression="com.elim.spring.aop.aspect.SchemaBasedAspect.pointcut()" id="pointcut"/>

<aop:aspect id="aspect1" ref="schemaBasedAspect" order="1">
 <!-- 定义一个Around Advice -->
 <aop:before method="doBefore" pointcut-ref="userServicePointCut" />
 <aop:around method="doAround" pointcut="bean(userService)"/>
 <aop:pointcut expression="bean(userService)" id="userServicePointCut"/>
</aop:aspect>

<aop:after-returning method="doAfterReturning" pointcut-ref="pointcut" returning="returnValue"/>
<aop:after-throwing method="doAfterThrowing" pointcut-ref="pointcut" throwing="ex"/>

<aop:aspect id="aspect1" ref="schemaBasedAspect" order="1">
 <aop:before method="doBefore" pointcut-ref="userServicePointCut"/>
 <aop:around method="doAround" pointcut="bean(userService)" />
 <aop:pointcut expression="bean(userService) &amp;&amp; args(id)" id="userServicePointCut"/>
</aop:aspect>

public void doBefore(int id) {
 System.out.println("======================doBefore======================" + id);
}

public void doBefore(CommonParent commonParent) {
 System.out.println("======================doBefore======================");
 commonParent.doSomething();
}

<bean id="schemaBasedAspect" class="com.elim.spring.aop.aspect.SchemaBasedAspect" />
<bean id="commonParent" class="com.elim.spring.aop.service.CommonParentImpl" />
<!-- 基于XML的AOP配置是基于config元素开始的 -->
<aop:config>
 <aop:aspect id="aspect1" ref="schemaBasedAspect" order="1">
  <aop:before method="doBefore" pointcut-ref="userServicePointCut" />
  <aop:pointcut expression="bean(userService) and this(commonParent) and !execution(void com.elim.spring.aop.service.CommonParent.doSomething())"
   id="userServicePointCut" />
  <!-- 加上通用的父类 -->
  <aop:declare-parents types-matching="com.elim.spring.aop.service..*"
   implement-interface="com.elim.spring.aop.service.CommonParent"
   delegate-ref="commonParent"/>
 </aop:aspect>
</aop:config>

<aop:aspectj-autoproxy proxy-target-class="true" />

<aop:config proxy-target-class="true">
</aop:config>

<aop:config>
 <aop:advisor advice-ref="" pointcut-ref=""/>
</aop:config>

public class LogBeforeAdvice implements MethodBeforeAdvice {

 @Override
 public void before(Method method, Object[] args, Object target) throws Throwable {
  System.out.println("===============before advice start==============");
  System.out.println("method: " + method);
  System.out.println("args: " + args);
  System.out.println("target: " + target);
  System.out.println("===============before advice end================");
 }

}

<aop:config>
 <aop:pointcut expression="bean(userService)" id="userServicePointcut"/> 
 <aop:advisor advice-ref="logBeforeAdvice" order="1" pointcut-ref="userServicePointcut"/>
</aop:config>

<bean id="logBeforeAdvice" class="com.elim.spring.aop.advice.LogBeforeAdvice" />

public class LogAroundAdvice implements MethodInterceptor {

 @Override
 public Object invoke(MethodInvocation invocation) throws Throwable {
  System.out.println("=============================方法调用开始===" + invocation.getMethod());
  try {
   Object result = invocation.proceed();
   System.out.println("=============================方法调用正常结束===" + invocation.getMethod());
   return result;
  } catch (Exception e) {
   System.out.println("=============================方法调用异常===" + invocation.getMethod());
   throw e;
  }
 }
}

public class LogAroundAdvice implements MethodInterceptor {

 @Override
 public Object invoke(MethodInvocation invocation) throws Throwable {
  System.out.println("=============================方法调用开始===" + invocation.getMethod());
  try {
   Object result = invocation.getMethod().invoke(invocation.getThis(), 1);
   System.out.println("=============================方法调用正常结束===" + invocation.getMethod());
   return result;
  } catch (Exception e) {
   System.out.println("=============================方法调用异常===" + invocation.getMethod());
   throw e;
  }
 }

}

<aop:config>
 <aop:pointcut expression="bean(userService)" id="userServicePointcut"/> 
 <aop:advisor advice-ref="logAroundAdvice" pointcut-ref="userServicePointcut"/>
</aop:config>

<bean id="logAroundAdvice" class="com.elim.spring.aop.advice.LogAroundAdvice"/>

public interface AfterReturningAdvice extends AfterAdvice {

 void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable;

}

public class LogAfterReturningAdvice implements AfterReturningAdvice {

 @Override
 public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
  System.out.println("==============调用成功返回，返回值是：" + returnValue);
  System.out.println("Method: " + method);
  if (returnValue instanceof User) {
   //不能修改返回值，但可以修改返回值的某些属性，因为是对象引用
   ((User) returnValue).setName("modifyedName");
  }
 }

}

public class LogThrowsAdvice implements ThrowsAdvice {

 /**
  * 处理IllegalArgumentException
  * @param e
  */
 public void afterThrowing(IllegalArgumentException e) {
  System.out.println("=====================方法调用异常，抛出了IllegalArgumentException");
 }
 
 /**
  * 处理NumberFormatException
  * @param e
  */
 public void afterThrowing(NumberFormatException e) {
  System.out.println("=====================方法调用异常，抛出了NumberFormatException");
 }
 
 /**
  * 处理其它所有的异常
  * @param method
  * @param args
  * @param target
  * @param e
  */
 public void afterThrowing(Method method, Object[] args, Object target, Exception e) {
  System.out.println("=====================方法调用异常了，" + e);
  System.out.println("Method: " + method);
  System.out.println("Args: " + args);
  System.out.println("Target: " + target);
 }
 
}

<aop:config>
 <aop:pointcut expression="bean(userService)" id="userServicePointcut"/> 
 <aop:advisor advice-ref="logBeforeAdvice" order="1" pointcut-ref="userServicePointcut"/>
 <aop:advisor advice-ref="logThrowsAdvice" order="2" pointcut-ref="userServicePointcut" />
 <aop:advisor advice-ref="logAfterReturningAdvice" order="3" pointcut-ref="userServicePointcut"/>
 <aop:advisor advice-ref="logAroundAdvice" pointcut-ref="userServicePointcut"/>
</aop:config>

<bean id="logBeforeAdvice" class="com.elim.spring.aop.advice.LogBeforeAdvice" />
<bean id="logThrowsAdvice" class="com.elim.spring.aop.advice.LogThrowsAdvice" />
<bean id="logAfterReturningAdvice" class="com.elim.spring.aop.advice.LogAfterReturningAdvice" />
<bean id="logAroundAdvice" class="com.elim.spring.aop.advice.LogAroundAdvice"/>

 <bean id="regexPointcut" class="org.springframework.aop.support.JdkRegexpMethodPointcut">
  <property name="patterns">
         <list>
             <value>find.*</value><!-- 所有方法名以find开始的方法 -->
         </list>
     </property>
 </bean>

 protected boolean matchesPattern(String signatureString) {
  for (int i = 0; i < this.patterns.length; i++) {
   boolean matched = matches(signatureString, i);
   if (matched) {
    for (int j = 0; j < this.excludedPatterns.length; j++) {
     boolean excluded = matchesExclusion(signatureString, j);
     if (excluded) {
      return false;
     }
    }
    return true;
   }
  }
  return false;
 }

  <aop:config>
    <aop:advisor advice-ref="logBeforeAdvice" pointcut-ref="regexPointcut"/>
  </aop:config>
 <bean id="logBeforeAdvice" class="com.elim.learn.spring.aop.advice.LogBeforeAdvice" />
 <bean id="regexPointcut" class="org.springframework.aop.support.JdkRegexpMethodPointcut">
  <property name="patterns">
         <list>
             <value>find.*</value><!-- 所有方法名以find开始的方法 -->
         </list>
     </property>
 </bean>

 <bean class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
  <property name="advice" ref="logBeforeAdvice"/>
  <property name="pattern" value="find.*"/>
 </bean>

public interface Pointcut {

 ClassFilter getClassFilter();

 MethodMatcher getMethodMatcher();

 Pointcut TRUE = TruePointcut.INSTANCE;

}

public interface ClassFilter {

 boolean matches(Class<?> clazz);

 ClassFilter TRUE = TrueClassFilter.INSTANCE;

}

public interface MethodMatcher {

 boolean matches(Method method, Class<?> targetClass);

 boolean isRuntime();

 boolean matches(Method method, Class<?> targetClass, Object[] args);

 MethodMatcher TRUE = TrueMethodMatcher.INSTANCE;

}

import java.lang.reflect.Method;

import org.springframework.aop.ClassFilter;
import org.springframework.aop.MethodMatcher;
import org.springframework.aop.Pointcut;

/**
 * 自定义Pointcut
 * @author Elim
 * 2017年5月8日
 */
public class MyCustomPointcut implements Pointcut {

 @Override
 public ClassFilter getClassFilter() {
  return new MyCustomClassFilter();
 }

 @Override
 public MethodMatcher getMethodMatcher() {
  return new MyCustomMethodMatcher();
 }
 
 private static class MyCustomClassFilter implements ClassFilter {

  @Override
  public boolean matches(Class<?> clazz) {
   //实现自己的判断逻辑，这里简单的判断对应Class的名称是以Service结尾的就表示匹配
   return clazz.getName().endsWith("Service");
  }
  
 }
 
 private static class MyCustomMethodMatcher implements MethodMatcher {

  @Override
  public boolean matches(Method method, Class<?> targetClass) {
   //实现方法匹配逻辑
   return method.getName().startsWith("find");
  }

  @Override
  public boolean isRuntime() {
   return false;
  }

  @Override
  public boolean matches(Method method, Class<?> targetClass, Object[] args) {
   return false;
  }
  
 }

}

  <aop:config>
   <aop:advisor advice-ref="logAroundAdvice" pointcut-ref="myCustomPointcut"/>
  </aop:config>
 <bean id="logAroundAdvice" class="com.elim.learn.spring.aop.advice.LogAroundAdvice"/>
 <bean id="myCustomPointcut" class="com.elim.learn.spring.aop.pointcut.MyCustomPointcut"/>

public class FindMethodMatcherPointcut extends StaticMethodMatcherPointcut {

 @Override
 public boolean matches(Method method, Class<?> targetClass) {
  return method.getName().startsWith("find");
 }

}

 @Test
 public void testProxyFactory() {
  MyService myService = new MyService();
  ProxyFactory proxyFactory = new ProxyFactory(myService);
  proxyFactory.addAdvice(new MethodBeforeAdvice() {

   @Override
   public void before(Method method, Object[] args,
                            Object target) throws Throwable {
    System.out.println("执行目标方法调用之前的逻辑");
    //不需要手动去调用目标方法，
                                //Spring内置逻辑里面会调用目标方法
   }
   
  });;
  MyService proxy = (MyService) proxyFactory.getProxy();
  proxy.add();
 }

 public AopProxy createAopProxy(AdvisedSupport config) 
            throws AopConfigException {
  if (config.isOptimize() || config.isProxyTargetClass()
                     || hasNoUserSuppliedProxyInterfaces(config)) {
   Class<?> targetClass = config.getTargetClass();
   if (targetClass == null) {
    

throw new AopConfigException("TargetSource cannot determine target class: " +
 "Either an interface or a target is required for proxy creation.");
   }
   if (targetClass.isInterface()) {
    return new JdkDynamicAopProxy(config);
   }
   return new ObjenesisCglibAopProxy(config);
  }
  else {
   return new JdkDynamicAopProxy(config);
  }
 }

/**
 * 简单的实现自己的PointcutAdvisor
 * @author Elim 2017年5月9日
 */
public class MyAdvisor implements PointcutAdvisor {

 @Override
 public Advice getAdvice() {
  return new MethodBeforeAdvice() {

   @Override
   public void before(Method method, Object[] args, 
  
                            Object target) throws Throwable {
    

System.out.println("BeforeAdvice实现，在目标方法被调用前调用，目标方法是：" 

+ method.getDeclaringClass().getName() + "."
      + method.getName());
   }
  };
 }

 @Override
 public boolean isPerInstance() {
  return true;
 }

 @Override
 public Pointcut getPointcut() {
  //匹配所有的方法调用
  return Pointcut.TRUE;
 }

}
 @Test
 public void testProxyFactory2() {
  MyService myService = new MyService();
  ProxyFactory proxyFactory = new ProxyFactory(myService);
  proxyFactory.addAdvisor(new MyAdvisor());
  MyService proxy = (MyService) proxyFactory.getProxy();
  proxy.add();
 }

 @Test
 public void testProxyFactory2() {
  MyService myService = new MyService();
  ProxyFactory proxyFactory = new ProxyFactory(myService);
  proxyFactory.setExposeProxy(true);//指定对外发布代理对象，即在目标对象方法中可以通过AopContext.currentProxy()访问当前代理对象。
  proxyFactory.addAdvisor(new MyAdvisor());
  proxyFactory.addAdvisor(new MyAdvisor());//多次指定Advisor将同时应用多个Advisor
  MyService proxy = (MyService) proxyFactory.getProxy();
  proxy.add();
 }

@Aspect
public class MyAspect {

 @Pointcut("execution(* add(..))")
 private void beforeAdd() {}
 
 @Before("beforeAdd()")
 public void before1() {
  System.out.println("-----------before-----------");
 }
 
}

@Test
public void testAspectJProxyFactory() {
 MyService myService = new MyService();
 AspectJProxyFactory proxyFactory = new AspectJProxyFactory(myService);
 proxyFactory.addAspect(MyAspect.class);
 proxyFactory.setProxyTargetClass(true);//是否需要使用CGLIB代理
 MyService proxy = proxyFactory.getProxy();
 proxy.add();
}

public void addAspect(Class<?> aspectClass) {
 String aspectName = aspectClass.getName();
 AspectMetadata am = createAspectMetadata(aspectClass, aspectName);
 MetadataAwareAspectInstanceFactory instanceFactory = 
            createAspectInstanceFactory(am, aspectClass, aspectName);
 addAdvisorsFromAspectInstanceFactory(instanceFactory);
}

private void addAdvisorsFromAspectInstanceFactory(
    MetadataAwareAspectInstanceFactory instanceFactory) {
 List<Advisor> advisors = this.aspectFactory.getAdvisors(instanceFactory);
 advisors = AopUtils.findAdvisorsThatCanApply(advisors, getTargetClass());
 AspectJProxyUtils.makeAdvisorChainAspectJCapableIfNecessary(advisors);
 OrderComparator.sort(advisors);
 addAdvisors(advisors);
}

<bean id="proxyFactoryBeanTestService" 
  class="org.springframework.aop.framework.ProxyFactoryBean">
  <property name="target"><!-- 指定被代理的对象 -->
    <bean class="com.elim.learn.spring.aop.service.ProxyFactoryBeanTestService"/>
  </property>
  <property name="proxyTargetClass" value="true"/><!-- 指定启用基于Class的代理 -->
  <!-- 指定生成的代理对象需要绑定的Advice或Advisor在bean容器中的名称 -->
  <property name="interceptorNames">
    <list>
      <value>logAroundAdvice</value>
    </list>
  </property>
</bean>

<bean id="proxyFactoryBeanTestService" 
  class="org.springframework.aop.framework.ProxyFactoryBean">
  <property name="target"><!-- 指定被代理的对象 -->
    <bean class=" com.elim.learn.spring.aop.service.ProxyFactoryBeanTestService"/>
  </property>
  <property name="proxyTargetClass" value="true"/><!-- 指定启用基于Class的代理 -->
  <!-- 指定生成的代理对象需要绑定的Advice或Advisor在bean容器中的名称 -->
  <property name="interceptorNames">
    <list>
      <value>abc*</value>
    </list>
  </property>
</bean>

<bean id="userService" class="com.elim.learn.spring.aop.service.UserServiceImpl"/>
<bean id="myService" class="com.elim.learn.spring.aop.service.MyService"/>
 
<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
 <!-- 匹配userService和所有名称以my开头的bean -->
 <property name="beanNames" value="userService, my*"/>
 <!-- interceptorNames中不能使用通配符，只能是精确匹配，
             即精确指定Advisor/Advice的bean名称 -->
 <property name="interceptorNames" value="logBeforeAdvice, myAdvisor "/>
</bean>
 
<bean id="logBeforeAdvice" 
    class="com.elim.learn.spring.aop.advice.LogBeforeAdvice" />
  
<bean id="myAdvisor" class="com.elim.learn.spring.aop.advisor.MyAdvisor"/>

<bean id="userService" class="com.elim.learn.spring.aop.service.UserServiceImpl"/>
<bean id="myService" class="com.elim.learn.spring.aop.service.MyService"/>
 
<bean 
 class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/>
 
<bean id="myAdvisor" class="com.elim.learn.spring.aop.advisor.MyAdvisor"/>

<bean 
  class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator">
 <property name="usePrefix" value="true" />
 <!-- 匹配所有bean名称以my开始的Advisor -->
 <property name="advisorBeanNamePrefix" value="my" />
</bean>

@Override
public Object getProxy() {
 return getProxy(ClassUtils.getDefaultClassLoader());
}

@Override
public Object getProxy(ClassLoader classLoader) {
 if (logger.isDebugEnabled()) {
  logger.debug("Creating JDK dynamic proxy: target source is " 
                + this.advised.getTargetSource());
 }
 Class<?>[] proxiedInterfaces = AopProxyUtils
            .completeProxiedInterfaces(this.advised);
 findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
 return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}

public static Class<?>[] completeProxiedInterfaces(AdvisedSupport advised) {
 Class<?>[] specifiedInterfaces = advised.getProxiedInterfaces();
 if (specifiedInterfaces.length == 0) {
  // No user-specified interfaces: 
                //check whether target class is an interface.
  Class<?> targetClass = advised.getTargetClass();
  if (targetClass != null && targetClass.isInterface()) {
   specifiedInterfaces = new Class<?>[] {targetClass};
  }
 }
 boolean addSpringProxy = !advised.isInterfaceProxied(SpringProxy.class);
 boolean addAdvised = !advised.isOpaque() 
                && !advised.isInterfaceProxied(Advised.class);
 int nonUserIfcCount = 0;
 if (addSpringProxy) {
  nonUserIfcCount++;
 }
 if (addAdvised) {
  nonUserIfcCount++;
 }
 Class<?>[] proxiedInterfaces = new Class<?>[specifiedInterfaces.length
                 + nonUserIfcCount];
 System.arraycopy(specifiedInterfaces, 0, 
                proxiedInterfaces, 0, specifiedInterfaces.length);
 if (addSpringProxy) {
  proxiedInterfaces[specifiedInterfaces.length]
                     = SpringProxy.class;
 }
 if (addAdvised) {
  proxiedInterfaces[proxiedInterfaces.length - 1] = Advised.class;
 }
 return proxiedInterfaces;
}

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
 MethodInvocation invocation;
 Object oldProxy = null;
 boolean setProxyContext = false;

 TargetSource targetSource = this.advised.targetSource;
 Class<?> targetClass = null;
 Object target = null;

 try {
  if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
   // The target does not implement 
                        // the equals(Object) method itself.
   return equals(args[0]);
  }
  if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
   // The target does not implement the hashCode() 
                        // method itself.
   return hashCode();
  }
  if (!this.advised.opaque 
                    && method.getDeclaringClass().isInterface() &&
  method.getDeclaringClass().isAssignableFrom(Advised.class)) {
   // Service invocations on ProxyConfig with the proxy config...
   return AopUtils.invokeJoinpointUsingReflection(
                                  this.advised, method, args);
  }

  Object retVal;

  if (this.advised.exposeProxy) {
   // Make invocation available if necessary.
   oldProxy = AopContext.setCurrentProxy(proxy);
   setProxyContext = true;
  }

  // May be null. Get as late as possible to 
                // minimize the time we "own" the target,
  // in case it comes from a pool.
  target = targetSource.getTarget();
  if (target != null) {
   targetClass = target.getClass();
  }

  // Get the interception chain for this method.
  List<Object> chain = this.advised
                .getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

  // Check whether we have any advice. If we don't, 
                // we can fallback on direct
  // reflective invocation of the target, 
                // and avoid creating a MethodInvocation.
  if (chain.isEmpty()) {
   // We can skip creating a MethodInvocation: 
                        //just invoke the target directly
   // Note that the final invoker must be an 
                        // InvokerInterceptor so we know it does
   // nothing but a reflective operation on the target, 
                        // and no hot swapping or fancy proxying.
   retVal = AopUtils.invokeJoinpointUsingReflection(target, 
                                     method, args);
  } else {
   // We need to create a method invocation...
   invocation = new ReflectiveMethodInvocation(proxy, 
                               target, method, args, targetClass, chain);
   // Proceed to the joinpoint through the interceptor chain.
   retVal = invocation.proceed();
  }

  // Massage return value if necessary.
  Class<?> returnType = method.getReturnType();
  if (retVal != null && retVal == target && 
                                returnType.isInstance(proxy) &&
    !RawTargetAccess.class
                                .isAssignableFrom(method.getDeclaringClass())) {
   // Special case: it returned "this" and 
                        // the return type of the method
   // is type-compatible. Note that we can't help 
                        // if the target sets
   // a reference to itself in another returned object.
   retVal = proxy;
  } else if (retVal == null && returnType != Void.TYPE 
                        && returnType.isPrimitive()) {
  throw new AopInvocationException(
 "Null return value from advice does not match primitive return type for: " 
                + method);
  }
  return retVal;
 }
 finally {
  if (target != null && !targetSource.isStatic()) {
   // Must have come from TargetSource.
   targetSource.releaseTarget(target);
  }
  if (setProxyContext) {
   // Restore old proxy.
   AopContext.setCurrentProxy(oldProxy);
  }
 }
}

if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
  method.getDeclaringClass().isAssignableFrom(Advised.class)) {
 // Service invocations on ProxyConfig with the proxy config...
 return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
}

public interface Advised extends TargetClassAware {

 boolean isFrozen();

 boolean isProxyTargetClass();

 Class<?>[] getProxiedInterfaces();

 boolean isInterfaceProxied(Class<?> intf);

 void setTargetSource(TargetSource targetSource);

 TargetSource getTargetSource();

 void setExposeProxy(boolean exposeProxy);

 boolean isExposeProxy();

 void setPreFiltered(boolean preFiltered);

 boolean isPreFiltered();

 Advisor[] getAdvisors();

 void addAdvisor(Advisor advisor) throws AopConfigException;

 void addAdvisor(int pos, Advisor advisor) throws AopConfigException;

 boolean removeAdvisor(Advisor advisor);

 void removeAdvisor(int index) throws AopConfigException;

 int indexOf(Advisor advisor);

 boolean replaceAdvisor(Advisor a, Advisor b) throws AopConfigException;

 void addAdvice(Advice advice) throws AopConfigException;

 void addAdvice(int pos, Advice advice) throws AopConfigException;

 boolean removeAdvice(Advice advice);

 int indexOf(Advice advice);

 String toProxyConfigString();

}

public interface Advisor {

 Advice getAdvice();

 boolean isPerInstance();

}

public interface PointcutAdvisor extends Advisor {

 Pointcut getPointcut();

}

public class MyAdvisor implements PointcutAdvisor {

 @Override
 public Advice getAdvice() {
  return new MethodBeforeAdvice() {

   @Override
   public void before(Method method, 
                             Object[] args, Object target) throws Throwable {
 System.out.println("BeforeAdvice实现，在目标方法被调用前调用，目标方法是：" 
+ method.getDeclaringClass().getName() + "."
      + method.getName());
   }
  };
 }

 @Override
 public boolean isPerInstance() {
  return true;
 }

 @Override
 public Pointcut getPointcut() {
  /**
   * 简单的Pointcut定义，匹配所有类的find方法调用。
   */
  return new Pointcut() {

   @Override
   public ClassFilter getClassFilter() {
    return ClassFilter.TRUE;
   }

   @Override
   public MethodMatcher getMethodMatcher() {
    return new MethodMatcher() {

  @Override
  public boolean matches(Method method, Class<?> targetClass) {
   String methodName = method.getName();
   if ("find".equals(methodName)) {
    return true;
   }
   return false;
  }

     @Override
     public boolean isRuntime() {
      return false;
     }

  @Override
  public boolean matches(Method method, Class<?> targetClass,
                    Object[] args) {
   return false;
  }
     
    };
   }
   
  };
 }

}