【小家Spring】面向切面编程Spring AOP创建代理的方式:ProxyFactoryBean、ProxyFactory、AspectJProxyFactory(JDK Proxy和CGLIB)(中)

简介: 【小家Spring】面向切面编程Spring AOP创建代理的方式:ProxyFactoryBean、ProxyFactory、AspectJProxyFactory(JDK Proxy和CGLIB)(中)

DefaultAdvisorAdapterRegistry / AdvisorAdapterRegistry


public class DefaultAdvisorAdapterRegistry implements AdvisorAdapterRegistry, Serializable {
  通知器适配器集合
  private final List<AdvisorAdapter> adapters = new ArrayList<>(3);
  // 默认就支持这几种类型的适配器
  public DefaultAdvisorAdapterRegistry() {
    registerAdvisorAdapter(new MethodBeforeAdviceAdapter());
    registerAdvisorAdapter(new AfterReturningAdviceAdapter());
    registerAdvisorAdapter(new ThrowsAdviceAdapter());
  }
  将通知封装为通知器
  @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;
    // 如果是MethodInterceptor类型,就根本不用适配器。DefaultPointcutAdvisor是天生处理这种有连接点得通知器的
    if (advice instanceof MethodInterceptor) {
      // So well-known it doesn't even need an adapter.
      return new DefaultPointcutAdvisor(advice);
    }
    // 这一步很显然了,就是校验看看这个advice是否是我们支持的这些类型(系统默认给出3中,但是我们也可以自己往里添加注册的)
    for (AdvisorAdapter adapter : this.adapters) {
      // Check that it is supported.
      if (adapter.supportsAdvice(advice)) {
        // 如果是支持的,也是被包装成了一个通用类型的DefaultPointcutAdvisor
        return new DefaultPointcutAdvisor(advice);
      }
    }
    throw new UnknownAdviceTypeException(advice);
  }
  获得通知器的通知
  @Override
  public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {
    List<MethodInterceptor> interceptors = new ArrayList<>(3);
    Advice advice = advisor.getAdvice();
    if (advice instanceof MethodInterceptor) {
      interceptors.add((MethodInterceptor) advice);
    }
    // 从所支持的适配器中拿到拦截器通知器
    for (AdvisorAdapter adapter : this.adapters) {
      if (adapter.supportsAdvice(advice)) {
        // 这一步需要注意:一定要把从适配器中拿到MethodInterceptor类型的通知器
        interceptors.add(adapter.getInterceptor(advisor));
      }
    }
    if (interceptors.isEmpty()) {
      throw new UnknownAdviceTypeException(advisor.getAdvice());
    }
    return interceptors.toArray(new MethodInterceptor[0]);
  }
  注册通知适配器
  @Override
  public void registerAdvisorAdapter(AdvisorAdapter adapter) {
    this.adapters.add(adapter);
  }
}


下面看看具体的生成代理的两个方法:getSingletonInstance和newPrototypeInstance

getSingletonInstance:


  private synchronized Object getSingletonInstance() {
    // 如果是单例的,现在这里持有这个缓存  创建国就不会再创建了
    if (this.singletonInstance == null) {
      // 根据设置的targetName,去工厂里拿到这个bean对象(普通Bean被包装成SingletonTargetSource)
      this.targetSource = freshTargetSource();
      // 这一步是如果你手动没有去设置需要被代理的接口,Spring还是会去帮你找看你有没有实现啥接口,然后全部给你代理上。可见Spring的容错性是很强的
      if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) {
        // Rely on AOP infrastructure to tell us what interfaces to proxy.
        Class<?> targetClass = getTargetClass();
        if (targetClass == null) {
          throw new FactoryBeanNotInitializedException("Cannot determine target class for proxy");
        }
        setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));
      }
      // Initialize the shared singleton instance.
      super.setFrozen(this.freezeProxy);
      // createAopProxy()方法就是父类ProxyCreatorSupport的方法,它的具体原理在推荐的博文里已经讲过了,这里就不鳌诉了
      // 其中JdkDynamicAopProxy和CglibAopProxy对getProxy()方法的实现,也请参考前面分析
      this.singletonInstance = getProxy(createAopProxy());
    }
    return this.singletonInstance;
  }


newPrototypeInstance:

多例的生成,基本和单例差不多。只是没有缓存了、然后每次创建得事后都是copy一份配置出来,创建一个代理实例~~~有兴趣的自个看哈~


ProxyFactoryBean脱离IoC容器使用


虽然它大多数都是结合IoC容器一起使用,但是它脱离容器依然是可议单独使用的(毕竟生成代理得核心功能在父类ProxyCreatorSupport上,和容器无关的)。比如如下:

public class Main {
    public static void main(String[] args) {
        String pointcutExpression = "execution( int com.fsx.maintest.Person.run() )";
        // =============================================================
        //因为我们要使用AspectJ,所以此处采用AspectJProxyFactory,当然你也可以使用和容器相关的ProxyFactoryBean
        ProxyFactoryBean factory = new ProxyFactoryBean();
        factory.setTarget(new Person());
        //AspectJProxyFactory factory = new AspectJProxyFactory(new Person());
        //声明一个aspectj切点,一张切面
        AspectJExpressionPointcut cut = new AspectJExpressionPointcut();
        cut.setExpression(pointcutExpression); // 设置切点表达式
        // 声明一个通知(此处使用环绕通知 MethodInterceptor )
        Advice advice = (MethodInterceptor) invocation -> {
            System.out.println("============>放行前拦截...");
            Object obj = invocation.proceed();
            System.out.println("============>放行后拦截...");
            return obj;
        };
        //切面=切点+通知
        // 它还有个构造函数:DefaultPointcutAdvisor(Advice advice); 用的切面就是Pointcut.TRUE,所以如果你要指定切面,请使用自己指定的构造函数
        // Pointcut.TRUE:表示啥都返回true,也就是说这个切面作用于所有的方法上/所有的方法
        // addAdvice();方法最终内部都是被包装成一个 `DefaultPointcutAdvisor`,且使用的是Pointcut.TRUE切面,因此需要注意这些区别
        Advisor advisor = new DefaultPointcutAdvisor(cut, advice);
        factory.addAdvisor(advisor);
        //Person p = factory.getProxy();
        Person p = (Person) factory.getObject();
        // 执行方法
        p.run();
        p.run(10);
        p.say();
        p.sayHi("Jack");
        p.say("Tom", 666);
    }
}
class Person {
    public int run() {
        System.out.println("我在run...");
        return 0;
    }
    public void run(int i) {
        System.out.println("我在run...<" + i + ">");
    }
    public void say() {
        System.out.println("我在say...");
    }
    public void sayHi(String name) {
        System.out.println("Hi," + name + ",你好");
    }
    public int say(String name, int i) {
        System.out.println(name + "----" + i);
        return 0;
    }
}


输出:

============>放行前拦截...
我在run...
============>放行后拦截...
我在run...<10>
我在say...
Hi,Jack,你好
Tom----666


ProxyFactory


它和Spring容器没啥关系,可议直接创建代理来使用:


    public static void main(String[] args) {
        ProxyFactory proxyFactory = new ProxyFactory(new HelloServiceImpl());
        // 添加两个Advise,一个匿名内部类表示
        proxyFactory.addAdvice((AfterReturningAdvice) (returnValue, method, args1, target) ->
                System.out.println("AfterReturningAdvice method=" + method.getName()));
        proxyFactory.addAdvice(new LogMethodBeforeAdvice());
        HelloService proxy = (HelloService) proxyFactory.getProxy();
        proxy.hello();
    }
输出:
this is LogMethodBeforeAdvice
this is my method~~
AfterReturningAdvice method=hello


很显然它代理的Bean都是new出来的,所以比如HelloServiceImpl就不能和Spring IoC很好的结合了,所以一般都是Spring内部去使用。


public class ProxyFactory extends ProxyCreatorSupport {
  // 它提供了丰富的构造函数~~~
  public ProxyFactory() {
  }
  public ProxyFactory(Object target) {
    setTarget(target);
    setInterfaces(ClassUtils.getAllInterfaces(target));
  }
  public ProxyFactory(Class<?>... proxyInterfaces) {
    setInterfaces(proxyInterfaces);
  }
  public ProxyFactory(Class<?> proxyInterface, Interceptor interceptor) {
    addInterface(proxyInterface);
    addAdvice(interceptor);
  }
  public ProxyFactory(Class<?> proxyInterface, TargetSource targetSource) {
    addInterface(proxyInterface);
    setTargetSource(targetSource);
  }
  // 创建代理的语句:调用父类ProxyCreatorSupport#createAopProxy 此处就不用再解释了
  public Object getProxy() {
    return createAopProxy().getProxy();
  }
  public Object getProxy(@Nullable ClassLoader classLoader) {
    return createAopProxy().getProxy(classLoader);
  }
  // 主义这是个静态方法,可以一步到位,代理指定的接口
  public static <T> T getProxy(Class<T> proxyInterface, Interceptor interceptor) {
    return (T) new ProxyFactory(proxyInterface, interceptor).getProxy();
  }
  public static <T> T getProxy(Class<T> proxyInterface, TargetSource targetSource) {
    return (T) new ProxyFactory(proxyInterface, targetSource).getProxy();
  }
  // 注意:若调用此方法生成代理,就直接使用的是CGLIB的方式的
  public static Object getProxy(TargetSource targetSource) {
    if (targetSource.getTargetClass() == null) {
      throw new IllegalArgumentException("Cannot create class proxy for TargetSource with null target class");
    }
    ProxyFactory proxyFactory = new ProxyFactory();
    proxyFactory.setTargetSource(targetSource);
    proxyFactory.setProxyTargetClass(true);
    return proxyFactory.getProxy();
  }
}
原理

由源代码可议看出,ProxyFactory的原理就是ProxyCreatorSupport#createAopProxy这个方法,其余的没啥了


相关文章
|
29天前
|
XML 监控 安全
Spring特性之一——AOP面向切面编程
Spring特性之一——AOP面向切面编程
28 1
|
29天前
|
运维 Java 程序员
Spring5深入浅出篇:基于注解实现的AOP
# Spring5 AOP 深入理解:注解实现 本文介绍了基于注解的AOP编程步骤,包括原始对象、额外功能、切点和组装切面。步骤1-3旨在构建切面,与传统AOP相似。示例代码展示了如何使用`@Around`定义切面和执行逻辑。配置中,通过`@Aspect`和`@Around`注解定义切点,并在Spring配置中启用AOP自动代理。 进一步讨论了切点复用,避免重复代码以提高代码维护性。通过`@Pointcut`定义通用切点表达式,然后在多个通知中引用。此外,解释了AOP底层实现的两种动态代理方式:JDK动态代理和Cglib字节码增强,默认使用JDK,可通过配置切换到Cglib
|
10天前
|
Java Spring
【JavaEE进阶】 Spring AOP源码简单剖析
【JavaEE进阶】 Spring AOP源码简单剖析
|
10天前
|
Java Spring
【JavaEE进阶】 Spring AOP详解
【JavaEE进阶】 Spring AOP详解
|
10天前
|
数据采集 Java 程序员
【JavaEE进阶】 Spring AOP快速上手
【JavaEE进阶】 Spring AOP快速上手
|
15天前
|
Java Spring
|
16天前
|
Java Spring
|
16天前
|
前端开发 Java Maven
Spring AOP
Spring AOP
19 1
|
16天前
|
数据采集 XML 监控
Spring AOP
Spring AOP
37 2
|
16天前
|
Java 数据库 Spring
Spring 事务 (编程式 & 声明式, Spring 事务传播机制)
Spring 事务 (编程式 & 声明式, Spring 事务传播机制)
23 1