Spring之AOP适配器模式

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>4.3.21.RELEASE</version>
</dependency>
<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.12</version>
</dependency>
<dependency>
  <groupId>aopalliance</groupId>
  <artifactId>aopalliance</artifactId>
  <version>1.0</version>
</dependency>

/**
 * 目标对象 接口
 * @author 波波烤鸭
 * @email dengpbs@163.com
 *
 */
public interface SomeService {
  public void doSome();
}

/**
 * 目标对象
 * @author 波波烤鸭
 * @email dengpbs@163.com
 *
 */
public class SomeServiceImpl implements SomeService {
  @Override
  public void doSome() {
    System.out.println("目标对象....方法执行了");
  }
}

/**
 * 前置通知
 *    需要实现MethodBeforeAdvice接口
 * @author 波波烤鸭
 * @email dengpbs@163.com
 *
 */
public class MyMethodBeforeAdvice implements MethodBeforeAdvice {
  /**
   * method 目标方法
   * args 目标方法参数列表
   * target 目标对象
   */
  @Override
  public void before(Method method, Object[] args, Object target) throws Throwable {
    System.out.println("前置通知执行了....");
  }
}

<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
  xmlns:context="http://www.springframework.org/schema/context"
  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-4.3.xsd">
  <!-- 注册目标类 -->
  <bean id="someServiceImpl" class="com.dpb.service.SomeServiceImpl" ></bean>
  <!-- 注册前置通知 -->
  <bean class="com.dpb.schema.MyMethodBeforeAdvice" id="myMethodBeforeAdvice"></bean>
  <!-- 注册代理类 -->
  <bean id="proxyFactoryBean" class="org.springframework.aop.framework.ProxyFactoryBean">
    <!-- 指定目标对象 -->
    <property name="target" ref="someServiceImpl"/>
    <!-- 指定目标类实现的所有接口 -->
    <property name="interfaces" value="com.dpb.service.SomeService"/>
    <!-- 指定切面 -->
    <property name="interceptorNames" >
      <list>
        <value>myMethodBeforeAdvice</value>
      </list>
    </property>
  </bean>
</beans>

@Test
public void test1() {
  ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
  // 注意通过getBean获取增强的代理类！！！
  SomeService some = ac.getBean("proxyFactoryBean",SomeService.class);
  some.doSome();
}

public interface MethodBeforeAdvice extends BeforeAdvice {
  void before(Method method, Object[] args, Object target) throws Throwable;
}

public interface AdvisorAdapter {
  // 判断通知类型是否匹配
  boolean supportsAdvice(Advice advice);
  // 获取对应的拦截器
  MethodInterceptor getInterceptor(Advisor advisor);
}

class MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable {
  @Override
  public boolean supportsAdvice(Advice advice) {
    return (advice instanceof MethodBeforeAdvice);
  }
  @Override
  public MethodInterceptor getInterceptor(Advisor advisor) {
    MethodBeforeAdvice advice = (MethodBeforeAdvice) advisor.getAdvice();
    // 通知类型匹配对应的拦截器
    return new MethodBeforeAdviceInterceptor(advice);
  }
}

public class DefaultAdvisorAdapterRegistry implements AdvisorAdapterRegistry, Serializable {
  private final List<AdvisorAdapter> adapters = new ArrayList<AdvisorAdapter>(3);
  /**
   * Create a new DefaultAdvisorAdapterRegistry, registering well-known adapters.
   */
  public DefaultAdvisorAdapterRegistry() {
    // 注册相应的适配器
    registerAdvisorAdapter(new MethodBeforeAdviceAdapter());
    registerAdvisorAdapter(new AfterReturningAdviceAdapter());
    registerAdvisorAdapter(new ThrowsAdviceAdapter());
  }
  // 包装类  将通知转换为了 对应的适配器
  // 本案例中将 MyMethodBeforeAdvice转换为了MethodBeforeAdviceAdapter
  @Override
  public Advisor wrap(Object adviceObject) throws UnknownAdviceTypeException {
    if (adviceObject instanceof Advisor) {
      return (Advisor) adviceObject;
    }
    if (!(adviceObject instanceof Advice)) {
      throw new UnknownAdviceTypeException(adviceObject);
    }
    Advice advice = (Advice) adviceObject;
    if (advice instanceof MethodInterceptor) {
      // So well-known it doesn't even need an adapter.
      return new DefaultPointcutAdvisor(advice);
    }
    for (AdvisorAdapter adapter : this.adapters) {
      // Check that it is supported.
      if (adapter.supportsAdvice(advice)) {
        return new DefaultPointcutAdvisor(advice);
      }
    }
    throw new UnknownAdviceTypeException(advice);
  }
  // 获取适配器对应的所有的拦截器
  @Override
  public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {
    List<MethodInterceptor> interceptors = new ArrayList<MethodInterceptor>(3);
    Advice advice = advisor.getAdvice();
    if (advice instanceof MethodInterceptor) {
      interceptors.add((MethodInterceptor) advice);
    }
    for (AdvisorAdapter adapter : this.adapters) {
      if (adapter.supportsAdvice(advice)) {
                // 调用了适配器的方法
        interceptors.add(adapter.getInterceptor(advisor));
      }
    }
    if (interceptors.isEmpty()) {
      throw new UnknownAdviceTypeException(advisor.getAdvice());
    }
    return interceptors.toArray(new MethodInterceptor[interceptors.size()]);
  }
  @Override
  public void registerAdvisorAdapter(AdvisorAdapter adapter) {
    this.adapters.add(adapter);
  }
}

@Override
public Object invoke(MethodInvocation mi) throws Throwable {
  // 前置通知方法
  this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
  // 目标对象的方法
  return mi.proceed();
}